|
|
@@ -1525,723 +1525,735 @@ Listing:
|
|
|
1508 SymTab.IsOpenArray(t);
|
|
|
1509 IF isOpen THEN
|
|
|
1510 QbeGen.CopyOp("0", qlo);
|
|
|
- 1511 QbeGen.OpenHi(q, qhi)
|
|
|
- 1512 ELSE
|
|
|
- 1513 lo := SymTab.ArrayLo(t);
|
|
|
- 1514 hi := SymTab.ArrayHi(t);
|
|
|
- 1515 QbeGen.IntStr(lo, qlo);
|
|
|
- 1516 QbeGen.IntStr(hi, qhi)
|
|
|
- 1517 END;
|
|
|
- 1518 QbeGen.CheckRange(ql, qlo,
|
|
|
- 1519 qhi);
|
|
|
- 1520 eT := SymTab.ArrayElem(t);
|
|
|
- 1521 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
- 1522 t, qe);
|
|
|
- 1523 IF SymTab.ClassOf(eT) =
|
|
|
- 1524 SymTab.ClArray THEN
|
|
|
- 1525 QbeGen.ElemLoad(qe, eT, q)
|
|
|
- 1526 ELSE QbeGen.CopyOp(qe, q)
|
|
|
- 1527 END;
|
|
|
- 1528 t := eT; sfx := TRUE
|
|
|
- 1529 END; .)
|
|
|
- 1530 { "," Expr<it, iq>
|
|
|
- 1531 (. IF t = SymTab.InvalidType THEN
|
|
|
- 1532 ELSIF SymTab.ClassOf(t) #
|
|
|
- 1533 SymTab.ClArray THEN
|
|
|
- 1534 SemError(217);
|
|
|
- 1535 t := SymTab.InvalidType
|
|
|
- 1536 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
- 1537 AND (SymTab.ClassOf(it) #
|
|
|
- 1538 SymTab.ClChar) THEN
|
|
|
- 1539 SemError(218);
|
|
|
- 1540 t := SymTab.InvalidType
|
|
|
- 1541 ELSE
|
|
|
- 1542 QbeGen.WidenIndex(iq, ql);
|
|
|
- 1543 isOpen :=
|
|
|
- 1544 SymTab.IsOpenArray(t);
|
|
|
- 1545 IF isOpen THEN
|
|
|
- 1546 QbeGen.CopyOp("0", qlo);
|
|
|
- 1547 QbeGen.OpenHi(q, qhi)
|
|
|
- 1548 ELSE
|
|
|
- 1549 lo := SymTab.ArrayLo(t);
|
|
|
- 1550 hi := SymTab.ArrayHi(t);
|
|
|
- 1551 QbeGen.IntStr(lo, qlo);
|
|
|
- 1552 QbeGen.IntStr(hi, qhi)
|
|
|
- 1553 END;
|
|
|
- 1554 QbeGen.CheckRange(ql, qlo,
|
|
|
- 1555 qhi);
|
|
|
- 1556 eT := SymTab.ArrayElem(t);
|
|
|
- 1557 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
- 1558 t, qe);
|
|
|
- 1559 IF SymTab.ClassOf(eT) =
|
|
|
- 1560 SymTab.ClArray THEN
|
|
|
- 1561 QbeGen.ElemLoad(qe, eT, q)
|
|
|
- 1562 ELSE QbeGen.CopyOp(qe, q)
|
|
|
- 1563 END;
|
|
|
- 1564 t := eT; sfx := TRUE
|
|
|
- 1565 END; .) }
|
|
|
- 1566 "]"
|
|
|
- 1567 | "." GetIdent<fn>
|
|
|
- 1568 (. IF k = SymTab.KindModule THEN
|
|
|
- 1569 (* qualified L.x: materialize
|
|
|
- 1570 the export, then load it *)
|
|
|
- 1571 IF NOT SymTab.MaterializeAlias(n,
|
|
|
- 1572 fn, mal) THEN
|
|
|
- 1573 SemError(201);
|
|
|
- 1574 t := SymTab.InvalidType;
|
|
|
- 1575 QbeGen.CopyOp("0", q)
|
|
|
- 1576 ELSE
|
|
|
- 1577 QbeGen.CopyOp(mal, qn);
|
|
|
- 1578 t := SymTab.SymType(mal);
|
|
|
- 1579 k := SymTab.SymKind(mal);
|
|
|
- 1580 sfx := FALSE;
|
|
|
- 1581 IF k = SymTab.KindProc THEN
|
|
|
- 1582 (* call: ArgList supplies
|
|
|
- 1583 the value *)
|
|
|
- 1584 QbeGen.CopyOp("0", q)
|
|
|
- 1585 ELSIF NOT QbeGen.LoadDesignator(
|
|
|
- 1586 mal, t, k, q) THEN
|
|
|
- 1587 SemError(230);
|
|
|
- 1588 QbeGen.CopyOp("0", q)
|
|
|
- 1589 END
|
|
|
- 1590 END
|
|
|
- 1591 ELSIF t = SymTab.InvalidType THEN
|
|
|
- 1592 ELSIF (SymTab.ClassOf(t) #
|
|
|
- 1593 SymTab.ClRecord)
|
|
|
- 1594 AND (SymTab.ClassOf(t) #
|
|
|
- 1595 SymTab.ClClass) THEN
|
|
|
- 1596 SemError(215);
|
|
|
- 1597 t := SymTab.InvalidType
|
|
|
- 1598 ELSIF NOT SymTab.FieldExists(t,
|
|
|
- 1599 fn) THEN
|
|
|
- 1600 SemError(216);
|
|
|
- 1601 t := SymTab.InvalidType
|
|
|
- 1602 ELSE
|
|
|
- 1603 fo := SymTab.FieldOffset(t,
|
|
|
- 1604 fn);
|
|
|
- 1605 t := SymTab.FieldType(t, fn);
|
|
|
- 1606 QbeGen.FieldAddr(q, fo, qe);
|
|
|
- 1607 (* array fields are inline:
|
|
|
- 1608 the field address is the
|
|
|
- 1609 descriptor, like records *)
|
|
|
- 1610 QbeGen.CopyOp(qe, q);
|
|
|
- 1611 sfx := TRUE
|
|
|
- 1612 END; .)
|
|
|
- 1613 | "^"
|
|
|
- 1614 (. IF t = SymTab.InvalidType THEN
|
|
|
- 1615 ELSIF SymTab.ClassOf(t) #
|
|
|
- 1616 SymTab.ClPtr THEN
|
|
|
- 1617 SemError(219);
|
|
|
- 1618 t := SymTab.InvalidType
|
|
|
- 1619 ELSE
|
|
|
- 1620 bt := SymTab.PtrBase(t);
|
|
|
- 1621 IF bt = SymTab.InvalidType THEN
|
|
|
- 1622 ELSE
|
|
|
- 1623 IF sfx THEN
|
|
|
- 1624 QbeGen.ElemLoad(q, t,
|
|
|
- 1625 qb);
|
|
|
- 1626 QbeGen.CopyOp(qb, q)
|
|
|
- 1627 END;
|
|
|
- 1628 t := bt;
|
|
|
- 1629 IF (SymTab.ClassOf(bt) =
|
|
|
- 1630 SymTab.ClInt)
|
|
|
- 1631 OR (SymTab.ClassOf(bt) =
|
|
|
- 1632 SymTab.ClBool)
|
|
|
- 1633 OR (SymTab.ClassOf(bt) =
|
|
|
- 1634 SymTab.ClChar)
|
|
|
- 1635 OR (SymTab.ClassOf(bt) =
|
|
|
- 1636 SymTab.ClReal) THEN
|
|
|
- 1637 sfx := TRUE
|
|
|
- 1638 ELSE sfx := FALSE
|
|
|
- 1639 END
|
|
|
- 1640 END
|
|
|
- 1641 END; .) } .
|
|
|
- 1642 Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 1643 (. VAR t2: SymTab.TypeIndex;
|
|
|
- 1644 op: INTEGER;
|
|
|
- 1645 q2, qt, wl: QbeGen.QVal;
|
|
|
- 1646 isR: BOOLEAN; .)
|
|
|
- 1647 = SimExpr<t, q>
|
|
|
- 1648 [ Rel<op> SimExpr<t2, q2>
|
|
|
- 1649 (. IF op = SymTab.OpIn THEN
|
|
|
- 1650 IF SymTab.InCheck(t, t2) THEN
|
|
|
- 1651 IF (t = SymTab.InvalidType)
|
|
|
- 1652 OR (t2 = SymTab.InvalidType) THEN
|
|
|
- 1653 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
- 1654 ELSE
|
|
|
- 1655 QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
|
|
|
- 1656 SymTab.SetCount(t2), qt);
|
|
|
- 1657 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 1658 END
|
|
|
- 1659 ELSE SemError(222); t := SymTab.InvalidType;
|
|
|
- 1660 QbeGen.CopyOp("0", q)
|
|
|
- 1661 END
|
|
|
- 1662 ELSIF SymTab.RelCheck(t, t2, op) THEN
|
|
|
- 1663 IF (t = SymTab.InvalidType)
|
|
|
- 1664 OR (t2 = SymTab.InvalidType) THEN
|
|
|
- 1665 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
- 1666 ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
|
|
|
- 1667 OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
|
|
|
- 1668 IF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
|
|
|
- 1669 AND (op # SymTab.OpNeq2) THEN
|
|
|
- 1670 SemError(213); t := SymTab.InvalidType;
|
|
|
- 1671 QbeGen.CopyOp("0", q)
|
|
|
- 1672 ELSE
|
|
|
- 1673 QbeGen.CmpL(op, q, q2, qt);
|
|
|
- 1674 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 1675 END
|
|
|
- 1676 ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 1677 OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 1678 QbeGen.CmpSet(op, q, q2,
|
|
|
- 1679 SymTab.SetWords(t), SymTab.SetWords(t2), qt);
|
|
|
- 1680 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 1681 ELSIF SymTab.IsLongFamily(t)
|
|
|
- 1682 OR SymTab.IsLongFamily(t2) THEN
|
|
|
- 1683 IF SymTab.IsIntFamily(t) THEN
|
|
|
- 1684 QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
|
|
|
- 1685 END;
|
|
|
- 1686 IF SymTab.IsIntFamily(t2) THEN
|
|
|
- 1687 QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
|
|
|
- 1688 END;
|
|
|
- 1689 QbeGen.CmpLong(op, q, q2, qt);
|
|
|
- 1690 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 1691 ELSE
|
|
|
- 1692 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 1693 t := SymTab.BoolType();
|
|
|
- 1694 QbeGen.Cmp(op, q, q2, qt, isR);
|
|
|
- 1695 QbeGen.CopyOp(qt, q)
|
|
|
- 1696 END
|
|
|
- 1697 ELSE SemError(213); t := SymTab.InvalidType;
|
|
|
- 1698 QbeGen.CopyOp("0", q)
|
|
|
- 1699 END; .) ] .
|
|
|
- 1700 Rel<VAR op: INTEGER>
|
|
|
- 1701 = "=" (. op := SymTab.OpEq; .)
|
|
|
- 1702 | "#" (. op := SymTab.OpNeq1; .)
|
|
|
- 1703 | "<" (. op := SymTab.OpLt; .)
|
|
|
- 1704 | "<=" (. op := SymTab.OpLe; .)
|
|
|
- 1705 | ">" (. op := SymTab.OpGt; .)
|
|
|
- 1706 | ">=" (. op := SymTab.OpGe; .)
|
|
|
- 1707 | "IN" (. op := SymTab.OpIn; .) .
|
|
|
- 1708 SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 1709 (. VAR t2, res2, lt, rt:
|
|
|
- 1710 SymTab.TypeIndex;
|
|
|
- 1711 op: INTEGER;
|
|
|
- 1712 q2, qt, wq, qf:
|
|
|
- 1713 QbeGen.QVal;
|
|
|
- 1714 neg, isR, isL, folded:
|
|
|
- 1715 BOOLEAN;
|
|
|
- 1716 lw, rw, mw: CARDINAL; .)
|
|
|
- 1717 = (. neg := FALSE; .)
|
|
|
- 1718 [ "+" | "-" (. neg := TRUE; .) ]
|
|
|
- 1719 Term<t, q> (. IF neg THEN
|
|
|
- 1720 IF QbeGen.IsImm(q) THEN
|
|
|
- 1721 QbeGen.NegFold(q, q)
|
|
|
- 1722 ELSE QbeGen.NewTemp(qt);
|
|
|
- 1723 QbeGen.NegQ(q, qt,
|
|
|
- 1724 SymTab.ClassOf(t)
|
|
|
- 1725 = SymTab.ClReal);
|
|
|
- 1726 QbeGen.CopyOp(qt, q)
|
|
|
- 1727 END
|
|
|
- 1728 END; .)
|
|
|
- 1729 { AddOp<op> Term<t2, q2>
|
|
|
- 1730 (. IF op = SymTab.OpOr THEN
|
|
|
- 1731 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
- 1732 t := SymTab.BoolType()
|
|
|
- 1733 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
- 1734 IF t # SymTab.InvalidType THEN
|
|
|
- 1735 QbeGen.NewTemp(qt);
|
|
|
- 1736 QbeGen.Op3("or", qt, q, q2, FALSE);
|
|
|
- 1737 QbeGen.CopyOp(qt, q)
|
|
|
- 1738 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 1739 END
|
|
|
- 1740 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
- 1741 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 1742 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 1743 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
- 1744 mw := lw;
|
|
|
- 1745 IF rw > mw THEN mw := rw END;
|
|
|
- 1746 IF op = SymTab.OpAdd THEN
|
|
|
- 1747 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
|
|
|
- 1748 ELSE
|
|
|
- 1749 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
|
|
|
- 1750 END;
|
|
|
- 1751 t := SymTab.NewSet(
|
|
|
- 1752 SymTab.NewSubR(0,
|
|
|
- 1753 VAL(INTEGER, mw) * 32 - 1));
|
|
|
- 1754 QbeGen.CopyOp(qt, q)
|
|
|
- 1755 ELSE
|
|
|
- 1756 IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
|
|
|
- 1757 lt := t; rt := t2; t := res2
|
|
|
- 1758 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
- 1759 IF t # SymTab.InvalidType THEN
|
|
|
- 1760 isL := SymTab.IsLongFamily(t);
|
|
|
- 1761 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 1762 folded := FALSE;
|
|
|
- 1763 IF (NOT isL) AND (NOT isR)
|
|
|
- 1764 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
- 1765 IF op = SymTab.OpAdd THEN
|
|
|
- 1766 folded := QbeGen.Fold2(0, q, q2, qf)
|
|
|
- 1767 ELSE
|
|
|
- 1768 folded := QbeGen.Fold2(1, q, q2, qf)
|
|
|
- 1769 END
|
|
|
- 1770 END;
|
|
|
- 1771 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
- 1772 ELSE
|
|
|
- 1773 IF isL THEN
|
|
|
- 1774 IF SymTab.IsIntFamily(lt) THEN
|
|
|
- 1775 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
- 1776 END;
|
|
|
- 1777 IF SymTab.IsIntFamily(rt) THEN
|
|
|
- 1778 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
- 1779 END;
|
|
|
- 1780 QbeGen.NewTemp(qt);
|
|
|
- 1781 IF op = SymTab.OpAdd THEN
|
|
|
- 1782 QbeGen.Op3L("add", qt, q, q2)
|
|
|
- 1783 ELSE
|
|
|
- 1784 QbeGen.Op3L("sub", qt, q, q2)
|
|
|
- 1785 END
|
|
|
- 1786 ELSE
|
|
|
- 1787 QbeGen.NewTemp(qt);
|
|
|
- 1788 IF op = SymTab.OpAdd THEN
|
|
|
- 1789 QbeGen.Op3("add", qt, q, q2, isR)
|
|
|
- 1790 ELSE
|
|
|
- 1791 QbeGen.Op3("sub", qt, q, q2, isR)
|
|
|
- 1792 END
|
|
|
- 1793 END;
|
|
|
- 1794 QbeGen.CopyOp(qt, q)
|
|
|
- 1795 END
|
|
|
- 1796 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 1797 END
|
|
|
- 1798 END; .) } .
|
|
|
- 1799 AddOp<VAR op: INTEGER>
|
|
|
- 1800 = "+" (. op := SymTab.OpAdd; .)
|
|
|
- 1801 | "-" (. op := SymTab.OpSub; .)
|
|
|
- 1802 | "OR" (. op := SymTab.OpOr; .) .
|
|
|
- 1803 Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 1804 (. VAR t2, res2, lt, rt:
|
|
|
- 1805 SymTab.TypeIndex;
|
|
|
- 1806 op: INTEGER;
|
|
|
- 1807 q2, qt, wq, qf:
|
|
|
- 1808 QbeGen.QVal;
|
|
|
- 1809 isR, isL, folded: BOOLEAN;
|
|
|
- 1810 lw, rw, mw: CARDINAL; .)
|
|
|
- 1811 = Fact<t, q> { MulOp<op> Fact<t2, q2>
|
|
|
- 1812 (. IF op = SymTab.OpAnd THEN
|
|
|
- 1813 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
- 1814 t := SymTab.BoolType()
|
|
|
- 1815 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
- 1816 IF t # SymTab.InvalidType THEN
|
|
|
- 1817 QbeGen.NewTemp(qt);
|
|
|
- 1818 QbeGen.Op3("and", qt, q, q2, FALSE);
|
|
|
- 1819 QbeGen.CopyOp(qt, q)
|
|
|
- 1820 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 1821 END
|
|
|
- 1822 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
- 1823 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 1824 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 1825 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
- 1826 mw := lw;
|
|
|
- 1827 IF rw > mw THEN mw := rw END;
|
|
|
- 1828 IF op = SymTab.OpTimes THEN
|
|
|
- 1829 QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
|
|
|
- 1830 ELSE
|
|
|
- 1831 QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
|
|
|
- 1832 END;
|
|
|
- 1833 t := SymTab.NewSet(
|
|
|
- 1834 SymTab.NewSubR(0,
|
|
|
- 1835 VAL(INTEGER, mw) * 32 - 1));
|
|
|
- 1836 QbeGen.CopyOp(qt, q)
|
|
|
- 1837 ELSE
|
|
|
- 1838 IF SymTab.ArithCheck(t, t2,
|
|
|
- 1839 (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
|
|
|
- 1840 res2) THEN
|
|
|
- 1841 lt := t; rt := t2; t := res2
|
|
|
- 1842 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
- 1843 IF t # SymTab.InvalidType THEN
|
|
|
- 1844 isL := SymTab.IsLongFamily(t);
|
|
|
- 1845 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 1846 folded := FALSE;
|
|
|
- 1847 IF (NOT isL) AND (NOT isR)
|
|
|
- 1848 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
- 1849 IF op = SymTab.OpTimes THEN
|
|
|
- 1850 folded := QbeGen.Fold2(2, q, q2, qf)
|
|
|
- 1851 ELSIF op = SymTab.OpDiv THEN
|
|
|
- 1852 folded := QbeGen.Fold2(3, q, q2, qf)
|
|
|
- 1853 ELSIF op = SymTab.OpMod THEN
|
|
|
- 1854 folded := QbeGen.Fold2(4, q, q2, qf)
|
|
|
- 1855 END
|
|
|
- 1856 END;
|
|
|
- 1857 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
- 1858 ELSE
|
|
|
- 1859 IF isL THEN
|
|
|
- 1860 IF SymTab.IsIntFamily(lt) THEN
|
|
|
- 1861 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
- 1862 END;
|
|
|
- 1863 IF SymTab.IsIntFamily(rt) THEN
|
|
|
- 1864 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
- 1865 END;
|
|
|
- 1866 QbeGen.NewTemp(qt);
|
|
|
- 1867 IF op = SymTab.OpTimes THEN
|
|
|
- 1868 QbeGen.Op3L("mul", qt, q, q2)
|
|
|
- 1869 ELSIF (op = SymTab.OpDiv)
|
|
|
- 1870 OR (op = SymTab.OpSlash) THEN
|
|
|
- 1871 QbeGen.Op3L("div", qt, q, q2)
|
|
|
- 1872 ELSE
|
|
|
- 1873 QbeGen.Op3L("rem", qt, q, q2)
|
|
|
- 1874 END
|
|
|
- 1875 ELSE
|
|
|
- 1876 QbeGen.NewTemp(qt);
|
|
|
- 1877 IF op = SymTab.OpTimes THEN
|
|
|
- 1878 QbeGen.Op3("mul", qt, q, q2, isR)
|
|
|
- 1879 ELSIF (op = SymTab.OpDiv)
|
|
|
- 1880 OR (op = SymTab.OpSlash) THEN
|
|
|
- 1881 QbeGen.Op3("div", qt, q, q2, isR)
|
|
|
- 1882 ELSE
|
|
|
- 1883 QbeGen.Op3("rem", qt, q, q2, isR)
|
|
|
- 1884 END
|
|
|
- 1885 END;
|
|
|
- 1886 QbeGen.CopyOp(qt, q)
|
|
|
- 1887 END
|
|
|
- 1888 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 1889 END
|
|
|
- 1890 END; .) } .
|
|
|
- 1891 MulOp<VAR op: INTEGER>
|
|
|
- 1892 = "*" (. op := SymTab.OpTimes; .)
|
|
|
- 1893 | "/" (. op := SymTab.OpSlash; .)
|
|
|
- 1894 | "DIV" (. op := SymTab.OpDiv; .)
|
|
|
- 1895 | "MOD" (. op := SymTab.OpMod; .)
|
|
|
- 1896 | ( "AND" | "&" ) (. op := SymTab.OpAnd; .) .
|
|
|
- 1897 Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 1898 (. VAR s: ARRAY [0 .. 255] OF CHAR;
|
|
|
- 1899 et, dt, t2, st, ct2:
|
|
|
- 1900 SymTab.TypeIndex;
|
|
|
- 1901 dk: INTEGER;
|
|
|
- 1902 qd, q2, sq, qa, qm0, qr:
|
|
|
- 1903 QbeGen.QVal;
|
|
|
- 1904 qn, vn: SymTab.Name;
|
|
|
- 1905 vt: SymTab.TypeIndex;
|
|
|
- 1906 c1, c2: INTEGER;
|
|
|
- 1907 called, isHigh, sfx, isCh:
|
|
|
- 1908 BOOLEAN; .)
|
|
|
- 1909 = integer (. LexString(s);
|
|
|
- 1910 QbeGen.NormInt(s, q);
|
|
|
- 1911 t := SymTab.IntType(); .)
|
|
|
- 1912 | charConst (. LexString(s);
|
|
|
- 1913 QbeGen.NormLit(s, q, isCh);
|
|
|
- 1914 t := SymTab.CharType(); .)
|
|
|
- 1915 | real (. LexString(s);
|
|
|
- 1916 QbeGen.NormReal(s, q);
|
|
|
- 1917 t := SymTab.RealType(); .)
|
|
|
- 1918 | string (. LexString(s);
|
|
|
- 1919 IF SymTab.StrLen(s) = 3 THEN
|
|
|
- 1920 t := SymTab.CharType();
|
|
|
- 1921 QbeGen.IntStr(
|
|
|
- 1922 QbeGen.CharVal(s), q)
|
|
|
- 1923 ELSE t := SymTab.NewStr();
|
|
|
- 1924 QbeGen.DeclStr(s, q);
|
|
|
- 1925 (* a literal's value IS its
|
|
|
- 1926 static descriptor address *)
|
|
|
- 1927 QbeGen.NoteAddr(q, q)
|
|
|
- 1928 END; .)
|
|
|
- 1929 | Design<dt, dk, qd, qn, sfx> (. called := FALSE;
|
|
|
- 1930 t := dt;
|
|
|
- 1931 IF sfx THEN
|
|
|
- 1932 IF dt =
|
|
|
- 1933 SymTab.InvalidType THEN
|
|
|
- 1934 QbeGen.CopyOp("0", q)
|
|
|
- 1935 ELSIF (SymTab.ClassOf(dt) =
|
|
|
- 1936 SymTab.ClRecord)
|
|
|
- 1937 OR (SymTab.ClassOf(dt) =
|
|
|
- 1938 SymTab.ClSet)
|
|
|
- 1939 OR (SymTab.ClassOf(dt) =
|
|
|
- 1940 SymTab.ClArray)
|
|
|
- 1941 OR (SymTab.ClassOf(dt) =
|
|
|
- 1942 SymTab.ClClass) THEN
|
|
|
- 1943 QbeGen.CopyOp(qd, q)
|
|
|
- 1944 ELSE QbeGen.ElemLoad(qd, dt,
|
|
|
- 1945 q)
|
|
|
- 1946 END
|
|
|
- 1947 ELSE QbeGen.CopyOp(qd, q)
|
|
|
- 1948 END;
|
|
|
- 1949 IF (dk = SymTab.KindVar)
|
|
|
- 1950 OR (dk = SymTab.KindParam)
|
|
|
- 1951 OR (dk =
|
|
|
- 1952 SymTab.KindField) THEN
|
|
|
- 1953 IF sfx THEN
|
|
|
- 1954 QbeGen.NoteAddr(q, qd)
|
|
|
- 1955 ELSE
|
|
|
- 1956 QbeGen.AddrOf(qn, qa);
|
|
|
- 1957 QbeGen.NoteAddr(q, qa)
|
|
|
+ 1511 IF SymTab.IsCharArray(t) THEN
|
|
|
+ 1512 QbeGen.OpenHiChar(q, qhi)
|
|
|
+ 1513 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
+ 1514 END
|
|
|
+ 1515 ELSE
|
|
|
+ 1516 lo := SymTab.ArrayLo(t);
|
|
|
+ 1517 hi := SymTab.ArrayHi(t);
|
|
|
+ 1518 IF SymTab.IsCharArray(t) THEN
|
|
|
+ 1519 hi := hi + 1
|
|
|
+ 1520 END;
|
|
|
+ 1521 QbeGen.IntStr(lo, qlo);
|
|
|
+ 1522 QbeGen.IntStr(hi, qhi)
|
|
|
+ 1523 END;
|
|
|
+ 1524 QbeGen.CheckRange(ql, qlo,
|
|
|
+ 1525 qhi);
|
|
|
+ 1526 eT := SymTab.ArrayElem(t);
|
|
|
+ 1527 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
+ 1528 t, qe);
|
|
|
+ 1529 IF SymTab.ClassOf(eT) =
|
|
|
+ 1530 SymTab.ClArray THEN
|
|
|
+ 1531 QbeGen.ElemLoad(qe, eT, q)
|
|
|
+ 1532 ELSE QbeGen.CopyOp(qe, q)
|
|
|
+ 1533 END;
|
|
|
+ 1534 t := eT; sfx := TRUE
|
|
|
+ 1535 END; .)
|
|
|
+ 1536 { "," Expr<it, iq>
|
|
|
+ 1537 (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1538 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1539 SymTab.ClArray THEN
|
|
|
+ 1540 SemError(217);
|
|
|
+ 1541 t := SymTab.InvalidType
|
|
|
+ 1542 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
+ 1543 AND (SymTab.ClassOf(it) #
|
|
|
+ 1544 SymTab.ClChar) THEN
|
|
|
+ 1545 SemError(218);
|
|
|
+ 1546 t := SymTab.InvalidType
|
|
|
+ 1547 ELSE
|
|
|
+ 1548 QbeGen.WidenIndex(iq, ql);
|
|
|
+ 1549 isOpen :=
|
|
|
+ 1550 SymTab.IsOpenArray(t);
|
|
|
+ 1551 IF isOpen THEN
|
|
|
+ 1552 QbeGen.CopyOp("0", qlo);
|
|
|
+ 1553 IF SymTab.IsCharArray(t) THEN
|
|
|
+ 1554 QbeGen.OpenHiChar(q, qhi)
|
|
|
+ 1555 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
+ 1556 END
|
|
|
+ 1557 ELSE
|
|
|
+ 1558 lo := SymTab.ArrayLo(t);
|
|
|
+ 1559 hi := SymTab.ArrayHi(t);
|
|
|
+ 1560 IF SymTab.IsCharArray(t) THEN
|
|
|
+ 1561 hi := hi + 1
|
|
|
+ 1562 END;
|
|
|
+ 1563 QbeGen.IntStr(lo, qlo);
|
|
|
+ 1564 QbeGen.IntStr(hi, qhi)
|
|
|
+ 1565 END;
|
|
|
+ 1566 QbeGen.CheckRange(ql, qlo,
|
|
|
+ 1567 qhi);
|
|
|
+ 1568 eT := SymTab.ArrayElem(t);
|
|
|
+ 1569 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
+ 1570 t, qe);
|
|
|
+ 1571 IF SymTab.ClassOf(eT) =
|
|
|
+ 1572 SymTab.ClArray THEN
|
|
|
+ 1573 QbeGen.ElemLoad(qe, eT, q)
|
|
|
+ 1574 ELSE QbeGen.CopyOp(qe, q)
|
|
|
+ 1575 END;
|
|
|
+ 1576 t := eT; sfx := TRUE
|
|
|
+ 1577 END; .) }
|
|
|
+ 1578 "]"
|
|
|
+ 1579 | "." GetIdent<fn>
|
|
|
+ 1580 (. IF k = SymTab.KindModule THEN
|
|
|
+ 1581 (* qualified L.x: materialize
|
|
|
+ 1582 the export, then load it *)
|
|
|
+ 1583 IF NOT SymTab.MaterializeAlias(n,
|
|
|
+ 1584 fn, mal) THEN
|
|
|
+ 1585 SemError(201);
|
|
|
+ 1586 t := SymTab.InvalidType;
|
|
|
+ 1587 QbeGen.CopyOp("0", q)
|
|
|
+ 1588 ELSE
|
|
|
+ 1589 QbeGen.CopyOp(mal, qn);
|
|
|
+ 1590 t := SymTab.SymType(mal);
|
|
|
+ 1591 k := SymTab.SymKind(mal);
|
|
|
+ 1592 sfx := FALSE;
|
|
|
+ 1593 IF k = SymTab.KindProc THEN
|
|
|
+ 1594 (* call: ArgList supplies
|
|
|
+ 1595 the value *)
|
|
|
+ 1596 QbeGen.CopyOp("0", q)
|
|
|
+ 1597 ELSIF NOT QbeGen.LoadDesignator(
|
|
|
+ 1598 mal, t, k, q) THEN
|
|
|
+ 1599 SemError(230);
|
|
|
+ 1600 QbeGen.CopyOp("0", q)
|
|
|
+ 1601 END
|
|
|
+ 1602 END
|
|
|
+ 1603 ELSIF t = SymTab.InvalidType THEN
|
|
|
+ 1604 ELSIF (SymTab.ClassOf(t) #
|
|
|
+ 1605 SymTab.ClRecord)
|
|
|
+ 1606 AND (SymTab.ClassOf(t) #
|
|
|
+ 1607 SymTab.ClClass) THEN
|
|
|
+ 1608 SemError(215);
|
|
|
+ 1609 t := SymTab.InvalidType
|
|
|
+ 1610 ELSIF NOT SymTab.FieldExists(t,
|
|
|
+ 1611 fn) THEN
|
|
|
+ 1612 SemError(216);
|
|
|
+ 1613 t := SymTab.InvalidType
|
|
|
+ 1614 ELSE
|
|
|
+ 1615 fo := SymTab.FieldOffset(t,
|
|
|
+ 1616 fn);
|
|
|
+ 1617 t := SymTab.FieldType(t, fn);
|
|
|
+ 1618 QbeGen.FieldAddr(q, fo, qe);
|
|
|
+ 1619 (* array fields are inline:
|
|
|
+ 1620 the field address is the
|
|
|
+ 1621 descriptor, like records *)
|
|
|
+ 1622 QbeGen.CopyOp(qe, q);
|
|
|
+ 1623 sfx := TRUE
|
|
|
+ 1624 END; .)
|
|
|
+ 1625 | "^"
|
|
|
+ 1626 (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1627 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1628 SymTab.ClPtr THEN
|
|
|
+ 1629 SemError(219);
|
|
|
+ 1630 t := SymTab.InvalidType
|
|
|
+ 1631 ELSE
|
|
|
+ 1632 bt := SymTab.PtrBase(t);
|
|
|
+ 1633 IF bt = SymTab.InvalidType THEN
|
|
|
+ 1634 ELSE
|
|
|
+ 1635 IF sfx THEN
|
|
|
+ 1636 QbeGen.ElemLoad(q, t,
|
|
|
+ 1637 qb);
|
|
|
+ 1638 QbeGen.CopyOp(qb, q)
|
|
|
+ 1639 END;
|
|
|
+ 1640 t := bt;
|
|
|
+ 1641 IF (SymTab.ClassOf(bt) =
|
|
|
+ 1642 SymTab.ClInt)
|
|
|
+ 1643 OR (SymTab.ClassOf(bt) =
|
|
|
+ 1644 SymTab.ClBool)
|
|
|
+ 1645 OR (SymTab.ClassOf(bt) =
|
|
|
+ 1646 SymTab.ClChar)
|
|
|
+ 1647 OR (SymTab.ClassOf(bt) =
|
|
|
+ 1648 SymTab.ClReal) THEN
|
|
|
+ 1649 sfx := TRUE
|
|
|
+ 1650 ELSE sfx := FALSE
|
|
|
+ 1651 END
|
|
|
+ 1652 END
|
|
|
+ 1653 END; .) } .
|
|
|
+ 1654 Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 1655 (. VAR t2: SymTab.TypeIndex;
|
|
|
+ 1656 op: INTEGER;
|
|
|
+ 1657 q2, qt, wl: QbeGen.QVal;
|
|
|
+ 1658 isR: BOOLEAN; .)
|
|
|
+ 1659 = SimExpr<t, q>
|
|
|
+ 1660 [ Rel<op> SimExpr<t2, q2>
|
|
|
+ 1661 (. IF op = SymTab.OpIn THEN
|
|
|
+ 1662 IF SymTab.InCheck(t, t2) THEN
|
|
|
+ 1663 IF (t = SymTab.InvalidType)
|
|
|
+ 1664 OR (t2 = SymTab.InvalidType) THEN
|
|
|
+ 1665 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
+ 1666 ELSE
|
|
|
+ 1667 QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
|
|
|
+ 1668 SymTab.SetCount(t2), qt);
|
|
|
+ 1669 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 1670 END
|
|
|
+ 1671 ELSE SemError(222); t := SymTab.InvalidType;
|
|
|
+ 1672 QbeGen.CopyOp("0", q)
|
|
|
+ 1673 END
|
|
|
+ 1674 ELSIF SymTab.RelCheck(t, t2, op) THEN
|
|
|
+ 1675 IF (t = SymTab.InvalidType)
|
|
|
+ 1676 OR (t2 = SymTab.InvalidType) THEN
|
|
|
+ 1677 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
+ 1678 ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
|
|
|
+ 1679 OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
|
|
|
+ 1680 IF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
|
|
|
+ 1681 AND (op # SymTab.OpNeq2) THEN
|
|
|
+ 1682 SemError(213); t := SymTab.InvalidType;
|
|
|
+ 1683 QbeGen.CopyOp("0", q)
|
|
|
+ 1684 ELSE
|
|
|
+ 1685 QbeGen.CmpL(op, q, q2, qt);
|
|
|
+ 1686 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 1687 END
|
|
|
+ 1688 ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 1689 OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 1690 QbeGen.CmpSet(op, q, q2,
|
|
|
+ 1691 SymTab.SetWords(t), SymTab.SetWords(t2), qt);
|
|
|
+ 1692 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 1693 ELSIF SymTab.IsLongFamily(t)
|
|
|
+ 1694 OR SymTab.IsLongFamily(t2) THEN
|
|
|
+ 1695 IF SymTab.IsIntFamily(t) THEN
|
|
|
+ 1696 QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
|
|
|
+ 1697 END;
|
|
|
+ 1698 IF SymTab.IsIntFamily(t2) THEN
|
|
|
+ 1699 QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
|
|
|
+ 1700 END;
|
|
|
+ 1701 QbeGen.CmpLong(op, q, q2, qt);
|
|
|
+ 1702 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 1703 ELSE
|
|
|
+ 1704 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 1705 t := SymTab.BoolType();
|
|
|
+ 1706 QbeGen.Cmp(op, q, q2, qt, isR);
|
|
|
+ 1707 QbeGen.CopyOp(qt, q)
|
|
|
+ 1708 END
|
|
|
+ 1709 ELSE SemError(213); t := SymTab.InvalidType;
|
|
|
+ 1710 QbeGen.CopyOp("0", q)
|
|
|
+ 1711 END; .) ] .
|
|
|
+ 1712 Rel<VAR op: INTEGER>
|
|
|
+ 1713 = "=" (. op := SymTab.OpEq; .)
|
|
|
+ 1714 | "#" (. op := SymTab.OpNeq1; .)
|
|
|
+ 1715 | "<" (. op := SymTab.OpLt; .)
|
|
|
+ 1716 | "<=" (. op := SymTab.OpLe; .)
|
|
|
+ 1717 | ">" (. op := SymTab.OpGt; .)
|
|
|
+ 1718 | ">=" (. op := SymTab.OpGe; .)
|
|
|
+ 1719 | "IN" (. op := SymTab.OpIn; .) .
|
|
|
+ 1720 SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 1721 (. VAR t2, res2, lt, rt:
|
|
|
+ 1722 SymTab.TypeIndex;
|
|
|
+ 1723 op: INTEGER;
|
|
|
+ 1724 q2, qt, wq, qf:
|
|
|
+ 1725 QbeGen.QVal;
|
|
|
+ 1726 neg, isR, isL, folded:
|
|
|
+ 1727 BOOLEAN;
|
|
|
+ 1728 lw, rw, mw: CARDINAL; .)
|
|
|
+ 1729 = (. neg := FALSE; .)
|
|
|
+ 1730 [ "+" | "-" (. neg := TRUE; .) ]
|
|
|
+ 1731 Term<t, q> (. IF neg THEN
|
|
|
+ 1732 IF QbeGen.IsImm(q) THEN
|
|
|
+ 1733 QbeGen.NegFold(q, q)
|
|
|
+ 1734 ELSE QbeGen.NewTemp(qt);
|
|
|
+ 1735 QbeGen.NegQ(q, qt,
|
|
|
+ 1736 SymTab.ClassOf(t)
|
|
|
+ 1737 = SymTab.ClReal);
|
|
|
+ 1738 QbeGen.CopyOp(qt, q)
|
|
|
+ 1739 END
|
|
|
+ 1740 END; .)
|
|
|
+ 1741 { AddOp<op> Term<t2, q2>
|
|
|
+ 1742 (. IF op = SymTab.OpOr THEN
|
|
|
+ 1743 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
+ 1744 t := SymTab.BoolType()
|
|
|
+ 1745 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 1746 IF t # SymTab.InvalidType THEN
|
|
|
+ 1747 QbeGen.NewTemp(qt);
|
|
|
+ 1748 QbeGen.Op3("or", qt, q, q2, FALSE);
|
|
|
+ 1749 QbeGen.CopyOp(qt, q)
|
|
|
+ 1750 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 1751 END
|
|
|
+ 1752 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
+ 1753 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 1754 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 1755 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
+ 1756 mw := lw;
|
|
|
+ 1757 IF rw > mw THEN mw := rw END;
|
|
|
+ 1758 IF op = SymTab.OpAdd THEN
|
|
|
+ 1759 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
|
|
|
+ 1760 ELSE
|
|
|
+ 1761 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
|
|
|
+ 1762 END;
|
|
|
+ 1763 t := SymTab.NewSet(
|
|
|
+ 1764 SymTab.NewSubR(0,
|
|
|
+ 1765 VAL(INTEGER, mw) * 32 - 1));
|
|
|
+ 1766 QbeGen.CopyOp(qt, q)
|
|
|
+ 1767 ELSE
|
|
|
+ 1768 IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
|
|
|
+ 1769 lt := t; rt := t2; t := res2
|
|
|
+ 1770 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 1771 IF t # SymTab.InvalidType THEN
|
|
|
+ 1772 isL := SymTab.IsLongFamily(t);
|
|
|
+ 1773 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 1774 folded := FALSE;
|
|
|
+ 1775 IF (NOT isL) AND (NOT isR)
|
|
|
+ 1776 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
+ 1777 IF op = SymTab.OpAdd THEN
|
|
|
+ 1778 folded := QbeGen.Fold2(0, q, q2, qf)
|
|
|
+ 1779 ELSE
|
|
|
+ 1780 folded := QbeGen.Fold2(1, q, q2, qf)
|
|
|
+ 1781 END
|
|
|
+ 1782 END;
|
|
|
+ 1783 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
+ 1784 ELSE
|
|
|
+ 1785 IF isL THEN
|
|
|
+ 1786 IF SymTab.IsIntFamily(lt) THEN
|
|
|
+ 1787 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
+ 1788 END;
|
|
|
+ 1789 IF SymTab.IsIntFamily(rt) THEN
|
|
|
+ 1790 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
+ 1791 END;
|
|
|
+ 1792 QbeGen.NewTemp(qt);
|
|
|
+ 1793 IF op = SymTab.OpAdd THEN
|
|
|
+ 1794 QbeGen.Op3L("add", qt, q, q2)
|
|
|
+ 1795 ELSE
|
|
|
+ 1796 QbeGen.Op3L("sub", qt, q, q2)
|
|
|
+ 1797 END
|
|
|
+ 1798 ELSE
|
|
|
+ 1799 QbeGen.NewTemp(qt);
|
|
|
+ 1800 IF op = SymTab.OpAdd THEN
|
|
|
+ 1801 QbeGen.Op3("add", qt, q, q2, isR)
|
|
|
+ 1802 ELSE
|
|
|
+ 1803 QbeGen.Op3("sub", qt, q, q2, isR)
|
|
|
+ 1804 END
|
|
|
+ 1805 END;
|
|
|
+ 1806 QbeGen.CopyOp(qt, q)
|
|
|
+ 1807 END
|
|
|
+ 1808 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 1809 END
|
|
|
+ 1810 END; .) } .
|
|
|
+ 1811 AddOp<VAR op: INTEGER>
|
|
|
+ 1812 = "+" (. op := SymTab.OpAdd; .)
|
|
|
+ 1813 | "-" (. op := SymTab.OpSub; .)
|
|
|
+ 1814 | "OR" (. op := SymTab.OpOr; .) .
|
|
|
+ 1815 Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 1816 (. VAR t2, res2, lt, rt:
|
|
|
+ 1817 SymTab.TypeIndex;
|
|
|
+ 1818 op: INTEGER;
|
|
|
+ 1819 q2, qt, wq, qf:
|
|
|
+ 1820 QbeGen.QVal;
|
|
|
+ 1821 isR, isL, folded: BOOLEAN;
|
|
|
+ 1822 lw, rw, mw: CARDINAL; .)
|
|
|
+ 1823 = Fact<t, q> { MulOp<op> Fact<t2, q2>
|
|
|
+ 1824 (. IF op = SymTab.OpAnd THEN
|
|
|
+ 1825 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
+ 1826 t := SymTab.BoolType()
|
|
|
+ 1827 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 1828 IF t # SymTab.InvalidType THEN
|
|
|
+ 1829 QbeGen.NewTemp(qt);
|
|
|
+ 1830 QbeGen.Op3("and", qt, q, q2, FALSE);
|
|
|
+ 1831 QbeGen.CopyOp(qt, q)
|
|
|
+ 1832 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 1833 END
|
|
|
+ 1834 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
+ 1835 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 1836 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 1837 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
+ 1838 mw := lw;
|
|
|
+ 1839 IF rw > mw THEN mw := rw END;
|
|
|
+ 1840 IF op = SymTab.OpTimes THEN
|
|
|
+ 1841 QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
|
|
|
+ 1842 ELSE
|
|
|
+ 1843 QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
|
|
|
+ 1844 END;
|
|
|
+ 1845 t := SymTab.NewSet(
|
|
|
+ 1846 SymTab.NewSubR(0,
|
|
|
+ 1847 VAL(INTEGER, mw) * 32 - 1));
|
|
|
+ 1848 QbeGen.CopyOp(qt, q)
|
|
|
+ 1849 ELSE
|
|
|
+ 1850 IF SymTab.ArithCheck(t, t2,
|
|
|
+ 1851 (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
|
|
|
+ 1852 res2) THEN
|
|
|
+ 1853 lt := t; rt := t2; t := res2
|
|
|
+ 1854 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 1855 IF t # SymTab.InvalidType THEN
|
|
|
+ 1856 isL := SymTab.IsLongFamily(t);
|
|
|
+ 1857 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 1858 folded := FALSE;
|
|
|
+ 1859 IF (NOT isL) AND (NOT isR)
|
|
|
+ 1860 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
+ 1861 IF op = SymTab.OpTimes THEN
|
|
|
+ 1862 folded := QbeGen.Fold2(2, q, q2, qf)
|
|
|
+ 1863 ELSIF op = SymTab.OpDiv THEN
|
|
|
+ 1864 folded := QbeGen.Fold2(3, q, q2, qf)
|
|
|
+ 1865 ELSIF op = SymTab.OpMod THEN
|
|
|
+ 1866 folded := QbeGen.Fold2(4, q, q2, qf)
|
|
|
+ 1867 END
|
|
|
+ 1868 END;
|
|
|
+ 1869 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
+ 1870 ELSE
|
|
|
+ 1871 IF isL THEN
|
|
|
+ 1872 IF SymTab.IsIntFamily(lt) THEN
|
|
|
+ 1873 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
+ 1874 END;
|
|
|
+ 1875 IF SymTab.IsIntFamily(rt) THEN
|
|
|
+ 1876 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
+ 1877 END;
|
|
|
+ 1878 QbeGen.NewTemp(qt);
|
|
|
+ 1879 IF op = SymTab.OpTimes THEN
|
|
|
+ 1880 QbeGen.Op3L("mul", qt, q, q2)
|
|
|
+ 1881 ELSIF (op = SymTab.OpDiv)
|
|
|
+ 1882 OR (op = SymTab.OpSlash) THEN
|
|
|
+ 1883 QbeGen.Op3L("div", qt, q, q2)
|
|
|
+ 1884 ELSE
|
|
|
+ 1885 QbeGen.Op3L("rem", qt, q, q2)
|
|
|
+ 1886 END
|
|
|
+ 1887 ELSE
|
|
|
+ 1888 QbeGen.NewTemp(qt);
|
|
|
+ 1889 IF op = SymTab.OpTimes THEN
|
|
|
+ 1890 QbeGen.Op3("mul", qt, q, q2, isR)
|
|
|
+ 1891 ELSIF (op = SymTab.OpDiv)
|
|
|
+ 1892 OR (op = SymTab.OpSlash) THEN
|
|
|
+ 1893 QbeGen.Op3("div", qt, q, q2, isR)
|
|
|
+ 1894 ELSE
|
|
|
+ 1895 QbeGen.Op3("rem", qt, q, q2, isR)
|
|
|
+ 1896 END
|
|
|
+ 1897 END;
|
|
|
+ 1898 QbeGen.CopyOp(qt, q)
|
|
|
+ 1899 END
|
|
|
+ 1900 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 1901 END
|
|
|
+ 1902 END; .) } .
|
|
|
+ 1903 MulOp<VAR op: INTEGER>
|
|
|
+ 1904 = "*" (. op := SymTab.OpTimes; .)
|
|
|
+ 1905 | "/" (. op := SymTab.OpSlash; .)
|
|
|
+ 1906 | "DIV" (. op := SymTab.OpDiv; .)
|
|
|
+ 1907 | "MOD" (. op := SymTab.OpMod; .)
|
|
|
+ 1908 | ( "AND" | "&" ) (. op := SymTab.OpAnd; .) .
|
|
|
+ 1909 Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 1910 (. VAR s: ARRAY [0 .. 255] OF CHAR;
|
|
|
+ 1911 et, dt, t2, st, ct2:
|
|
|
+ 1912 SymTab.TypeIndex;
|
|
|
+ 1913 dk: INTEGER;
|
|
|
+ 1914 qd, q2, sq, qa, qm0, qr:
|
|
|
+ 1915 QbeGen.QVal;
|
|
|
+ 1916 qn, vn: SymTab.Name;
|
|
|
+ 1917 vt: SymTab.TypeIndex;
|
|
|
+ 1918 c1, c2: INTEGER;
|
|
|
+ 1919 called, isHigh, sfx, isCh:
|
|
|
+ 1920 BOOLEAN; .)
|
|
|
+ 1921 = integer (. LexString(s);
|
|
|
+ 1922 QbeGen.NormInt(s, q);
|
|
|
+ 1923 t := SymTab.IntType(); .)
|
|
|
+ 1924 | charConst (. LexString(s);
|
|
|
+ 1925 QbeGen.NormLit(s, q, isCh);
|
|
|
+ 1926 t := SymTab.CharType(); .)
|
|
|
+ 1927 | real (. LexString(s);
|
|
|
+ 1928 QbeGen.NormReal(s, q);
|
|
|
+ 1929 t := SymTab.RealType(); .)
|
|
|
+ 1930 | string (. LexString(s);
|
|
|
+ 1931 IF SymTab.StrLen(s) = 3 THEN
|
|
|
+ 1932 t := SymTab.CharType();
|
|
|
+ 1933 QbeGen.IntStr(
|
|
|
+ 1934 QbeGen.CharVal(s), q)
|
|
|
+ 1935 ELSE t := SymTab.NewStr();
|
|
|
+ 1936 QbeGen.DeclStr(s, q);
|
|
|
+ 1937 (* a literal's value IS its
|
|
|
+ 1938 static descriptor address *)
|
|
|
+ 1939 QbeGen.NoteAddr(q, q)
|
|
|
+ 1940 END; .)
|
|
|
+ 1941 | Design<dt, dk, qd, qn, sfx> (. called := FALSE;
|
|
|
+ 1942 t := dt;
|
|
|
+ 1943 IF sfx THEN
|
|
|
+ 1944 IF dt =
|
|
|
+ 1945 SymTab.InvalidType THEN
|
|
|
+ 1946 QbeGen.CopyOp("0", q)
|
|
|
+ 1947 ELSIF (SymTab.ClassOf(dt) =
|
|
|
+ 1948 SymTab.ClRecord)
|
|
|
+ 1949 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1950 SymTab.ClSet)
|
|
|
+ 1951 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1952 SymTab.ClArray)
|
|
|
+ 1953 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1954 SymTab.ClClass) THEN
|
|
|
+ 1955 QbeGen.CopyOp(qd, q)
|
|
|
+ 1956 ELSE QbeGen.ElemLoad(qd, dt,
|
|
|
+ 1957 q)
|
|
|
1958 END
|
|
|
- 1959 ELSIF sfx
|
|
|
- 1960 AND (dt #
|
|
|
- 1961 SymTab.InvalidType)
|
|
|
- 1962 AND ((SymTab.ClassOf(dt) =
|
|
|
- 1963 SymTab.ClArray)
|
|
|
- 1964 OR (SymTab.ClassOf(dt) =
|
|
|
- 1965 SymTab.ClSet)
|
|
|
- 1966 OR (SymTab.ClassOf(dt) =
|
|
|
- 1967 SymTab.ClRecord)) THEN
|
|
|
- 1968 QbeGen.NoteAddr(qd, qd)
|
|
|
- 1969 END; .)
|
|
|
- 1970 [ TypedSetLit<dt, q> (. t := dt; .) ]
|
|
|
- 1971 [ ArgList<qn, dt, qd, TRUE, ct2, q2, called>
|
|
|
- 1972 (. t := ct2;
|
|
|
- 1973 QbeGen.CopyOp(q2, q); .) ]
|
|
|
- 1974 (. IF NOT called
|
|
|
- 1975 AND (dk = SymTab.KindProc) THEN
|
|
|
- 1976 (* bare zero-arg function
|
|
|
- 1977 call (parentheses may be
|
|
|
- 1978 omitted); a proper or
|
|
|
- 1979 parameterised proc here
|
|
|
- 1980 is 230 *)
|
|
|
- 1981 IF (SymTab.ProcNPar(qn) = 0)
|
|
|
- 1982 AND (SymTab.ProcRes(qn) #
|
|
|
- 1983 SymTab.InvalidType) THEN
|
|
|
- 1984 QbeGen.Mangled(qn,
|
|
|
- 1985 SymTab.ProcUid(qn), qm0);
|
|
|
- 1986 QbeGen.CallBegin(qm0,
|
|
|
- 1987 SymTab.ProcRes(qn),
|
|
|
- 1988 SymTab.ProcDepthOf(qn),
|
|
|
- 1989 SymTab.IsExternal(qn));
|
|
|
- 1990 QbeGen.CallEnd(TRUE, q);
|
|
|
- 1991 t := SymTab.ProcRes(qn)
|
|
|
- 1992 ELSE
|
|
|
- 1993 (* procedure used as a
|
|
|
- 1994 value (assign to a
|
|
|
- 1995 procedure variable):
|
|
|
- 1996 its code address *)
|
|
|
- 1997 t := SymTab.ProcTypeOf(qn);
|
|
|
- 1998 QbeGen.Mangled(qn,
|
|
|
- 1999 SymTab.ProcUid(qn), qm0);
|
|
|
- 2000 QbeGen.ProcAddr(qm0, q)
|
|
|
- 2001 END
|
|
|
- 2002 END; .)
|
|
|
- 2003 | ( "HIGH" (. isHigh := TRUE; .)
|
|
|
- 2004 | ( "LEN" | "LENGTH" ) (. isHigh := FALSE; .) )
|
|
|
- 2005 "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 2006 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 2007 ELSIF SymTab.ClassOf(dt) #
|
|
|
- 2008 SymTab.ClArray THEN
|
|
|
- 2009 SemError(217);
|
|
|
- 2010 t := SymTab.InvalidType;
|
|
|
- 2011 QbeGen.CopyOp("0", q)
|
|
|
- 2012 ELSE
|
|
|
- 2013 IF isHigh THEN
|
|
|
- 2014 IF SymTab.IsOpenArray(dt) THEN
|
|
|
- 2015 QbeGen.OpenHi(qd, qr)
|
|
|
- 2016 ELSE
|
|
|
- 2017 QbeGen.IntStr(
|
|
|
- 2018 SymTab.ArrayHi(dt), qr)
|
|
|
- 2019 END
|
|
|
- 2020 ELSE
|
|
|
- 2021 IF SymTab.IsOpenArray(dt) THEN
|
|
|
- 2022 QbeGen.LoadCount(qd, qr)
|
|
|
- 2023 ELSE
|
|
|
- 2024 QbeGen.IntStr(VAL(
|
|
|
- 2025 INTEGER,
|
|
|
- 2026 SymTab.ArrayLen(dt)),
|
|
|
- 2027 qr)
|
|
|
- 2028 END
|
|
|
- 2029 END;
|
|
|
- 2030 t := SymTab.IntType();
|
|
|
- 2031 QbeGen.CopyOp(qr, q)
|
|
|
- 2032 END; .)
|
|
|
- 2033 | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 2034 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 2035 t := SymTab.InvalidType;
|
|
|
- 2036 QbeGen.CopyOp("0", q)
|
|
|
- 2037 ELSE
|
|
|
- 2038 QbeGen.IntStr(VAL(INTEGER,
|
|
|
- 2039 SymTab.ObjectSize(dt)), q);
|
|
|
- 2040 t := SymTab.IntType()
|
|
|
- 2041 END; .)
|
|
|
- 2042 | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 2043 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 2044 t := SymTab.InvalidType;
|
|
|
- 2045 QbeGen.CopyOp("0", q)
|
|
|
- 2046 ELSE
|
|
|
- 2047 IF sfx THEN
|
|
|
- 2048 QbeGen.CopyOp(qd, q)
|
|
|
- 2049 ELSIF (dk = SymTab.KindVar)
|
|
|
- 2050 OR (dk = SymTab.KindParam) THEN
|
|
|
- 2051 QbeGen.AddrOf(qn, q)
|
|
|
- 2052 ELSE SemError(230);
|
|
|
- 2053 QbeGen.CopyOp("0", q)
|
|
|
- 2054 END;
|
|
|
- 2055 t := SymTab.AddrType()
|
|
|
- 2056 END; .)
|
|
|
- 2057 | "CHR" "(" Expr<et, q> ")"
|
|
|
- 2058 (. IF (et # SymTab.InvalidType)
|
|
|
- 2059 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
- 2060 SemError(211) END;
|
|
|
- 2061 t := SymTab.CharType(); .)
|
|
|
- 2062 | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
|
|
|
- 2063 (. IF et # SymTab.InvalidType THEN
|
|
|
- 2064 IF (SymTab.ClassOf(et) #
|
|
|
- 2065 SymTab.ClChar)
|
|
|
- 2066 AND (SymTab.ClassOf(et) #
|
|
|
- 2067 SymTab.ClBool)
|
|
|
- 2068 AND (SymTab.ClassOf(et) #
|
|
|
- 2069 SymTab.ClEnum)
|
|
|
- 2070 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
- 2071 SemError(211) END
|
|
|
- 2072 END;
|
|
|
- 2073 t := SymTab.IntType(); .)
|
|
|
- 2074 | "CAP" "(" Expr<et, q> ")"
|
|
|
- 2075 (. QbeGen.CapQ(q, qa);
|
|
|
- 2076 QbeGen.CopyOp(qa, q);
|
|
|
- 2077 t := SymTab.CharType(); .)
|
|
|
- 2078 | "ABS" "(" Expr<et, q> ")"
|
|
|
- 2079 (. IF (et # SymTab.InvalidType)
|
|
|
- 2080 AND NOT SymTab.IsIntFamily(et)
|
|
|
- 2081 AND (SymTab.ClassOf(et) #
|
|
|
- 2082 SymTab.ClReal) THEN
|
|
|
- 2083 SemError(211)
|
|
|
- 2084 ELSE QbeGen.AbsQ(q, qa,
|
|
|
- 2085 SymTab.ClassOf(et) =
|
|
|
- 2086 SymTab.ClReal);
|
|
|
- 2087 QbeGen.CopyOp(qa, q)
|
|
|
- 2088 END;
|
|
|
- 2089 t := et; .)
|
|
|
- 2090 | "VAL" "(" GetIdent<vn> "," Expr<et, q> ")"
|
|
|
- 2091 (. IF NOT SymTab.Lookup(vn) THEN
|
|
|
- 2092 SemError(201);
|
|
|
- 2093 t := SymTab.InvalidType
|
|
|
- 2094 ELSE vt := SymTab.SymType(vn);
|
|
|
- 2095 IF vt = SymTab.InvalidType THEN
|
|
|
- 2096 t := SymTab.InvalidType
|
|
|
- 2097 ELSIF et =
|
|
|
- 2098 SymTab.InvalidType THEN
|
|
|
- 2099 t := vt
|
|
|
- 2100 ELSE
|
|
|
- 2101 c1 := SymTab.ClassOf(et);
|
|
|
- 2102 c2 := SymTab.ClassOf(vt);
|
|
|
- 2103 IF ((c1 = SymTab.ClInt)
|
|
|
- 2104 OR (c1 =
|
|
|
- 2105 SymTab.ClChar)
|
|
|
- 2106 OR (c1 =
|
|
|
- 2107 SymTab.ClBool)
|
|
|
- 2108 OR (c1 =
|
|
|
- 2109 SymTab.ClEnum))
|
|
|
- 2110 AND ((c2 = SymTab.ClInt)
|
|
|
- 2111 OR (c2 =
|
|
|
- 2112 SymTab.ClChar)
|
|
|
- 2113 OR (c2 =
|
|
|
- 2114 SymTab.ClBool)
|
|
|
- 2115 OR (c2 =
|
|
|
- 2116 SymTab.ClEnum)) THEN
|
|
|
- 2117 t := vt
|
|
|
- 2118 ELSIF (c1 = SymTab.ClPtr)
|
|
|
- 2119 AND (c2 = SymTab.ClPtr) THEN
|
|
|
- 2120 t := vt
|
|
|
- 2121 ELSIF (c1 = SymTab.ClReal)
|
|
|
- 2122 AND (c2 = SymTab.ClReal) THEN
|
|
|
- 2123 t := vt
|
|
|
- 2124 ELSE SemError(230);
|
|
|
- 2125 t := SymTab.InvalidType
|
|
|
- 2126 END
|
|
|
- 2127 END
|
|
|
- 2128 END; .)
|
|
|
- 2129 | "(" Expr<et, q> ")" (. t := et; .)
|
|
|
- 2130 | SetLit<st, sq> (. t := st;
|
|
|
- 2131 QbeGen.CopyOp(sq, q); .)
|
|
|
- 2132 | ( "NOT" | "~" ) Fact<t2, q2> (. IF SymTab.BoolCheck(t2) THEN
|
|
|
- 2133 t := SymTab.BoolType()
|
|
|
- 2134 ELSE SemError(212);
|
|
|
- 2135 t := SymTab.InvalidType END;
|
|
|
- 2136 IF t # SymTab.InvalidType THEN
|
|
|
- 2137 QbeGen.NotQ(q2, q)
|
|
|
- 2138 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 2139 END; .) .
|
|
|
- 2140 (* Set literals are SET OF [0..255] (8 words); elements validated
|
|
|
- 2141 0..255 statically when foldable (222 otherwise), runtime trap
|
|
|
- 2142 for computed elements. Ranges always lower via SetRange. *)
|
|
|
- 2143 SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 2144 = "{" (. t := SymTab.NewSet(
|
|
|
- 2145 SymTab.NewSubR(0, 255));
|
|
|
- 2146 QbeGen.NewSetTemp(8, q);
|
|
|
- 2147 QbeGen.SetZero(q, 8); .)
|
|
|
- 2148 [ SetElem<t, q> { "," SetElem<t, q> } ]
|
|
|
- 2149 "}" .
|
|
|
- 2150 (* Typed set constructor: TypeName{ elems } — e.g. BITSET{0},
|
|
|
- 2151 BITSET{}. The declared type (not SET OF [0..255]) sets the
|
|
|
- 2152 width and element span. *)
|
|
|
- 2153 TypedSetLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 2154 (. VAR nw: CARDINAL; .)
|
|
|
- 2155 = "{" (. IF SymTab.ClassOf(vt) #
|
|
|
- 2156 SymTab.ClSet THEN
|
|
|
- 2157 SemError(230); nw := 8
|
|
|
- 2158 ELSE nw := SymTab.SetWords(vt);
|
|
|
- 2159 IF nw = 0 THEN nw := 8 END
|
|
|
- 2160 END;
|
|
|
- 2161 QbeGen.NewSetTemp(nw, q);
|
|
|
- 2162 QbeGen.SetZero(q, nw); .)
|
|
|
- 2163 [ SetElem<vt, q> { "," SetElem<vt, q> } ]
|
|
|
- 2164 "}" .
|
|
|
- 2165 SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal> (. VAR et, et2: SymTab.TypeIndex;
|
|
|
- 2166 qe, q2: QbeGen.QVal;
|
|
|
- 2167 v, v2: INTEGER;
|
|
|
- 2168 lo: INTEGER;
|
|
|
- 2169 span: CARDINAL;
|
|
|
- 2170 cl, cl2: INTEGER;
|
|
|
- 2171 hasR: BOOLEAN; .)
|
|
|
- 2172 = (. hasR := FALSE; .)
|
|
|
- 2173 Expr<et, qe>
|
|
|
- 2174 [ ".." Expr<et2, q2> (. hasR := TRUE; .) ]
|
|
|
- 2175 (. lo := SymTab.SetBaseLo(st);
|
|
|
- 2176 span := SymTab.SetCount(st);
|
|
|
- 2177 IF (et = SymTab.InvalidType)
|
|
|
- 2178 OR (hasR AND (et2 =
|
|
|
- 2179 SymTab.InvalidType)) THEN
|
|
|
- 2180 ELSE cl :=
|
|
|
- 2181 SymTab.ClassOf(et);
|
|
|
- 2182 IF hasR THEN
|
|
|
- 2183 cl2 :=
|
|
|
- 2184 SymTab.ClassOf(et2)
|
|
|
- 2185 ELSE cl2 := SymTab.ClInt
|
|
|
- 2186 END;
|
|
|
- 2187 IF ((cl # SymTab.ClInt)
|
|
|
- 2188 AND (cl # SymTab.ClChar)
|
|
|
- 2189 AND (cl # SymTab.ClBool))
|
|
|
- 2190 OR (hasR AND
|
|
|
- 2191 ((cl2
|
|
|
- 2192 # SymTab.ClInt)
|
|
|
- 2193 AND (cl2
|
|
|
- 2194 # SymTab.ClChar)
|
|
|
- 2195 AND (cl2
|
|
|
- 2196 # SymTab.ClBool))) THEN
|
|
|
- 2197 SemError(222)
|
|
|
- 2198 ELSIF hasR
|
|
|
- 2199 AND SymTab.ConstInt(qe, v)
|
|
|
- 2200 AND SymTab.ConstInt(q2,
|
|
|
- 2201 v2)
|
|
|
- 2202 AND ((v < lo)
|
|
|
- 2203 OR (v2 < lo)
|
|
|
- 2204 OR (v >= lo +
|
|
|
- 2205 VAL(INTEGER, span))
|
|
|
- 2206 OR (v2 >= lo +
|
|
|
- 2207 VAL(INTEGER, span))
|
|
|
- 2208 OR (v > v2)) THEN
|
|
|
+ 1959 ELSE QbeGen.CopyOp(qd, q)
|
|
|
+ 1960 END;
|
|
|
+ 1961 IF (dk = SymTab.KindVar)
|
|
|
+ 1962 OR (dk = SymTab.KindParam)
|
|
|
+ 1963 OR (dk =
|
|
|
+ 1964 SymTab.KindField) THEN
|
|
|
+ 1965 IF sfx THEN
|
|
|
+ 1966 QbeGen.NoteAddr(q, qd)
|
|
|
+ 1967 ELSE
|
|
|
+ 1968 QbeGen.AddrOf(qn, qa);
|
|
|
+ 1969 QbeGen.NoteAddr(q, qa)
|
|
|
+ 1970 END
|
|
|
+ 1971 ELSIF sfx
|
|
|
+ 1972 AND (dt #
|
|
|
+ 1973 SymTab.InvalidType)
|
|
|
+ 1974 AND ((SymTab.ClassOf(dt) =
|
|
|
+ 1975 SymTab.ClArray)
|
|
|
+ 1976 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1977 SymTab.ClSet)
|
|
|
+ 1978 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1979 SymTab.ClRecord)) THEN
|
|
|
+ 1980 QbeGen.NoteAddr(qd, qd)
|
|
|
+ 1981 END; .)
|
|
|
+ 1982 [ TypedSetLit<dt, q> (. t := dt; .) ]
|
|
|
+ 1983 [ ArgList<qn, dt, qd, TRUE, ct2, q2, called>
|
|
|
+ 1984 (. t := ct2;
|
|
|
+ 1985 QbeGen.CopyOp(q2, q); .) ]
|
|
|
+ 1986 (. IF NOT called
|
|
|
+ 1987 AND (dk = SymTab.KindProc) THEN
|
|
|
+ 1988 (* bare zero-arg function
|
|
|
+ 1989 call (parentheses may be
|
|
|
+ 1990 omitted); a proper or
|
|
|
+ 1991 parameterised proc here
|
|
|
+ 1992 is 230 *)
|
|
|
+ 1993 IF (SymTab.ProcNPar(qn) = 0)
|
|
|
+ 1994 AND (SymTab.ProcRes(qn) #
|
|
|
+ 1995 SymTab.InvalidType) THEN
|
|
|
+ 1996 QbeGen.Mangled(qn,
|
|
|
+ 1997 SymTab.ProcUid(qn), qm0);
|
|
|
+ 1998 QbeGen.CallBegin(qm0,
|
|
|
+ 1999 SymTab.ProcRes(qn),
|
|
|
+ 2000 SymTab.ProcDepthOf(qn),
|
|
|
+ 2001 SymTab.IsExternal(qn));
|
|
|
+ 2002 QbeGen.CallEnd(TRUE, q);
|
|
|
+ 2003 t := SymTab.ProcRes(qn)
|
|
|
+ 2004 ELSE
|
|
|
+ 2005 (* procedure used as a
|
|
|
+ 2006 value (assign to a
|
|
|
+ 2007 procedure variable):
|
|
|
+ 2008 its code address *)
|
|
|
+ 2009 t := SymTab.ProcTypeOf(qn);
|
|
|
+ 2010 QbeGen.Mangled(qn,
|
|
|
+ 2011 SymTab.ProcUid(qn), qm0);
|
|
|
+ 2012 QbeGen.ProcAddr(qm0, q)
|
|
|
+ 2013 END
|
|
|
+ 2014 END; .)
|
|
|
+ 2015 | ( "HIGH" (. isHigh := TRUE; .)
|
|
|
+ 2016 | ( "LEN" | "LENGTH" ) (. isHigh := FALSE; .) )
|
|
|
+ 2017 "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 2018 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 2019 ELSIF SymTab.ClassOf(dt) #
|
|
|
+ 2020 SymTab.ClArray THEN
|
|
|
+ 2021 SemError(217);
|
|
|
+ 2022 t := SymTab.InvalidType;
|
|
|
+ 2023 QbeGen.CopyOp("0", q)
|
|
|
+ 2024 ELSE
|
|
|
+ 2025 IF isHigh THEN
|
|
|
+ 2026 IF SymTab.IsOpenArray(dt) THEN
|
|
|
+ 2027 QbeGen.OpenHi(qd, qr)
|
|
|
+ 2028 ELSE
|
|
|
+ 2029 QbeGen.IntStr(
|
|
|
+ 2030 SymTab.ArrayHi(dt), qr)
|
|
|
+ 2031 END
|
|
|
+ 2032 ELSE
|
|
|
+ 2033 IF SymTab.IsOpenArray(dt) THEN
|
|
|
+ 2034 QbeGen.LoadCount(qd, qr)
|
|
|
+ 2035 ELSE
|
|
|
+ 2036 QbeGen.IntStr(VAL(
|
|
|
+ 2037 INTEGER,
|
|
|
+ 2038 SymTab.ArrayLen(dt)),
|
|
|
+ 2039 qr)
|
|
|
+ 2040 END
|
|
|
+ 2041 END;
|
|
|
+ 2042 t := SymTab.IntType();
|
|
|
+ 2043 QbeGen.CopyOp(qr, q)
|
|
|
+ 2044 END; .)
|
|
|
+ 2045 | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 2046 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 2047 t := SymTab.InvalidType;
|
|
|
+ 2048 QbeGen.CopyOp("0", q)
|
|
|
+ 2049 ELSE
|
|
|
+ 2050 QbeGen.IntStr(VAL(INTEGER,
|
|
|
+ 2051 SymTab.ObjectSize(dt)), q);
|
|
|
+ 2052 t := SymTab.IntType()
|
|
|
+ 2053 END; .)
|
|
|
+ 2054 | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 2055 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 2056 t := SymTab.InvalidType;
|
|
|
+ 2057 QbeGen.CopyOp("0", q)
|
|
|
+ 2058 ELSE
|
|
|
+ 2059 IF sfx THEN
|
|
|
+ 2060 QbeGen.CopyOp(qd, q)
|
|
|
+ 2061 ELSIF (dk = SymTab.KindVar)
|
|
|
+ 2062 OR (dk = SymTab.KindParam) THEN
|
|
|
+ 2063 QbeGen.AddrOf(qn, q)
|
|
|
+ 2064 ELSE SemError(230);
|
|
|
+ 2065 QbeGen.CopyOp("0", q)
|
|
|
+ 2066 END;
|
|
|
+ 2067 t := SymTab.AddrType()
|
|
|
+ 2068 END; .)
|
|
|
+ 2069 | "CHR" "(" Expr<et, q> ")"
|
|
|
+ 2070 (. IF (et # SymTab.InvalidType)
|
|
|
+ 2071 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
+ 2072 SemError(211) END;
|
|
|
+ 2073 t := SymTab.CharType(); .)
|
|
|
+ 2074 | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
|
|
|
+ 2075 (. IF et # SymTab.InvalidType THEN
|
|
|
+ 2076 IF (SymTab.ClassOf(et) #
|
|
|
+ 2077 SymTab.ClChar)
|
|
|
+ 2078 AND (SymTab.ClassOf(et) #
|
|
|
+ 2079 SymTab.ClBool)
|
|
|
+ 2080 AND (SymTab.ClassOf(et) #
|
|
|
+ 2081 SymTab.ClEnum)
|
|
|
+ 2082 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
+ 2083 SemError(211) END
|
|
|
+ 2084 END;
|
|
|
+ 2085 t := SymTab.IntType(); .)
|
|
|
+ 2086 | "CAP" "(" Expr<et, q> ")"
|
|
|
+ 2087 (. QbeGen.CapQ(q, qa);
|
|
|
+ 2088 QbeGen.CopyOp(qa, q);
|
|
|
+ 2089 t := SymTab.CharType(); .)
|
|
|
+ 2090 | "ABS" "(" Expr<et, q> ")"
|
|
|
+ 2091 (. IF (et # SymTab.InvalidType)
|
|
|
+ 2092 AND NOT SymTab.IsIntFamily(et)
|
|
|
+ 2093 AND (SymTab.ClassOf(et) #
|
|
|
+ 2094 SymTab.ClReal) THEN
|
|
|
+ 2095 SemError(211)
|
|
|
+ 2096 ELSE QbeGen.AbsQ(q, qa,
|
|
|
+ 2097 SymTab.ClassOf(et) =
|
|
|
+ 2098 SymTab.ClReal);
|
|
|
+ 2099 QbeGen.CopyOp(qa, q)
|
|
|
+ 2100 END;
|
|
|
+ 2101 t := et; .)
|
|
|
+ 2102 | "VAL" "(" GetIdent<vn> "," Expr<et, q> ")"
|
|
|
+ 2103 (. IF NOT SymTab.Lookup(vn) THEN
|
|
|
+ 2104 SemError(201);
|
|
|
+ 2105 t := SymTab.InvalidType
|
|
|
+ 2106 ELSE vt := SymTab.SymType(vn);
|
|
|
+ 2107 IF vt = SymTab.InvalidType THEN
|
|
|
+ 2108 t := SymTab.InvalidType
|
|
|
+ 2109 ELSIF et =
|
|
|
+ 2110 SymTab.InvalidType THEN
|
|
|
+ 2111 t := vt
|
|
|
+ 2112 ELSE
|
|
|
+ 2113 c1 := SymTab.ClassOf(et);
|
|
|
+ 2114 c2 := SymTab.ClassOf(vt);
|
|
|
+ 2115 IF ((c1 = SymTab.ClInt)
|
|
|
+ 2116 OR (c1 =
|
|
|
+ 2117 SymTab.ClChar)
|
|
|
+ 2118 OR (c1 =
|
|
|
+ 2119 SymTab.ClBool)
|
|
|
+ 2120 OR (c1 =
|
|
|
+ 2121 SymTab.ClEnum))
|
|
|
+ 2122 AND ((c2 = SymTab.ClInt)
|
|
|
+ 2123 OR (c2 =
|
|
|
+ 2124 SymTab.ClChar)
|
|
|
+ 2125 OR (c2 =
|
|
|
+ 2126 SymTab.ClBool)
|
|
|
+ 2127 OR (c2 =
|
|
|
+ 2128 SymTab.ClEnum)) THEN
|
|
|
+ 2129 t := vt
|
|
|
+ 2130 ELSIF (c1 = SymTab.ClPtr)
|
|
|
+ 2131 AND (c2 = SymTab.ClPtr) THEN
|
|
|
+ 2132 t := vt
|
|
|
+ 2133 ELSIF (c1 = SymTab.ClReal)
|
|
|
+ 2134 AND (c2 = SymTab.ClReal) THEN
|
|
|
+ 2135 t := vt
|
|
|
+ 2136 ELSE SemError(230);
|
|
|
+ 2137 t := SymTab.InvalidType
|
|
|
+ 2138 END
|
|
|
+ 2139 END
|
|
|
+ 2140 END; .)
|
|
|
+ 2141 | "(" Expr<et, q> ")" (. t := et; .)
|
|
|
+ 2142 | SetLit<st, sq> (. t := st;
|
|
|
+ 2143 QbeGen.CopyOp(sq, q); .)
|
|
|
+ 2144 | ( "NOT" | "~" ) Fact<t2, q2> (. IF SymTab.BoolCheck(t2) THEN
|
|
|
+ 2145 t := SymTab.BoolType()
|
|
|
+ 2146 ELSE SemError(212);
|
|
|
+ 2147 t := SymTab.InvalidType END;
|
|
|
+ 2148 IF t # SymTab.InvalidType THEN
|
|
|
+ 2149 QbeGen.NotQ(q2, q)
|
|
|
+ 2150 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 2151 END; .) .
|
|
|
+ 2152 (* Set literals are SET OF [0..255] (8 words); elements validated
|
|
|
+ 2153 0..255 statically when foldable (222 otherwise), runtime trap
|
|
|
+ 2154 for computed elements. Ranges always lower via SetRange. *)
|
|
|
+ 2155 SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 2156 = "{" (. t := SymTab.NewSet(
|
|
|
+ 2157 SymTab.NewSubR(0, 255));
|
|
|
+ 2158 QbeGen.NewSetTemp(8, q);
|
|
|
+ 2159 QbeGen.SetZero(q, 8); .)
|
|
|
+ 2160 [ SetElem<t, q> { "," SetElem<t, q> } ]
|
|
|
+ 2161 "}" .
|
|
|
+ 2162 (* Typed set constructor: TypeName{ elems } — e.g. BITSET{0},
|
|
|
+ 2163 BITSET{}. The declared type (not SET OF [0..255]) sets the
|
|
|
+ 2164 width and element span. *)
|
|
|
+ 2165 TypedSetLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 2166 (. VAR nw: CARDINAL; .)
|
|
|
+ 2167 = "{" (. IF SymTab.ClassOf(vt) #
|
|
|
+ 2168 SymTab.ClSet THEN
|
|
|
+ 2169 SemError(230); nw := 8
|
|
|
+ 2170 ELSE nw := SymTab.SetWords(vt);
|
|
|
+ 2171 IF nw = 0 THEN nw := 8 END
|
|
|
+ 2172 END;
|
|
|
+ 2173 QbeGen.NewSetTemp(nw, q);
|
|
|
+ 2174 QbeGen.SetZero(q, nw); .)
|
|
|
+ 2175 [ SetElem<vt, q> { "," SetElem<vt, q> } ]
|
|
|
+ 2176 "}" .
|
|
|
+ 2177 SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal> (. VAR et, et2: SymTab.TypeIndex;
|
|
|
+ 2178 qe, q2: QbeGen.QVal;
|
|
|
+ 2179 v, v2: INTEGER;
|
|
|
+ 2180 lo: INTEGER;
|
|
|
+ 2181 span: CARDINAL;
|
|
|
+ 2182 cl, cl2: INTEGER;
|
|
|
+ 2183 hasR: BOOLEAN; .)
|
|
|
+ 2184 = (. hasR := FALSE; .)
|
|
|
+ 2185 Expr<et, qe>
|
|
|
+ 2186 [ ".." Expr<et2, q2> (. hasR := TRUE; .) ]
|
|
|
+ 2187 (. lo := SymTab.SetBaseLo(st);
|
|
|
+ 2188 span := SymTab.SetCount(st);
|
|
|
+ 2189 IF (et = SymTab.InvalidType)
|
|
|
+ 2190 OR (hasR AND (et2 =
|
|
|
+ 2191 SymTab.InvalidType)) THEN
|
|
|
+ 2192 ELSE cl :=
|
|
|
+ 2193 SymTab.ClassOf(et);
|
|
|
+ 2194 IF hasR THEN
|
|
|
+ 2195 cl2 :=
|
|
|
+ 2196 SymTab.ClassOf(et2)
|
|
|
+ 2197 ELSE cl2 := SymTab.ClInt
|
|
|
+ 2198 END;
|
|
|
+ 2199 IF ((cl # SymTab.ClInt)
|
|
|
+ 2200 AND (cl # SymTab.ClChar)
|
|
|
+ 2201 AND (cl # SymTab.ClBool))
|
|
|
+ 2202 OR (hasR AND
|
|
|
+ 2203 ((cl2
|
|
|
+ 2204 # SymTab.ClInt)
|
|
|
+ 2205 AND (cl2
|
|
|
+ 2206 # SymTab.ClChar)
|
|
|
+ 2207 AND (cl2
|
|
|
+ 2208 # SymTab.ClBool))) THEN
|
|
|
2209 SemError(222)
|
|
|
- 2210 ELSIF hasR THEN
|
|
|
- 2211 QbeGen.SetRange(sq, qe, q2,
|
|
|
- 2212 lo, span)
|
|
|
- 2213 ELSIF SymTab.ConstInt(qe,
|
|
|
- 2214 v)
|
|
|
- 2215 AND ((v < lo)
|
|
|
- 2216 OR (v >= lo +
|
|
|
- 2217 VAL(INTEGER,
|
|
|
- 2218 span))) THEN
|
|
|
- 2219 SemError(222)
|
|
|
- 2220 ELSE QbeGen.SetBit(sq, qe,
|
|
|
- 2221 lo, span)
|
|
|
- 2222 END
|
|
|
- 2223 END; .) .
|
|
|
- 2224 GetIdent<VAR n: SymTab.Name>
|
|
|
- 2225 = ident (. LexName(n); .) .
|
|
|
- 2226
|
|
|
- 2227 END M2.
|
|
|
+ 2210 ELSIF hasR
|
|
|
+ 2211 AND SymTab.ConstInt(qe, v)
|
|
|
+ 2212 AND SymTab.ConstInt(q2,
|
|
|
+ 2213 v2)
|
|
|
+ 2214 AND ((v < lo)
|
|
|
+ 2215 OR (v2 < lo)
|
|
|
+ 2216 OR (v >= lo +
|
|
|
+ 2217 VAL(INTEGER, span))
|
|
|
+ 2218 OR (v2 >= lo +
|
|
|
+ 2219 VAL(INTEGER, span))
|
|
|
+ 2220 OR (v > v2)) THEN
|
|
|
+ 2221 SemError(222)
|
|
|
+ 2222 ELSIF hasR THEN
|
|
|
+ 2223 QbeGen.SetRange(sq, qe, q2,
|
|
|
+ 2224 lo, span)
|
|
|
+ 2225 ELSIF SymTab.ConstInt(qe,
|
|
|
+ 2226 v)
|
|
|
+ 2227 AND ((v < lo)
|
|
|
+ 2228 OR (v >= lo +
|
|
|
+ 2229 VAL(INTEGER,
|
|
|
+ 2230 span))) THEN
|
|
|
+ 2231 SemError(222)
|
|
|
+ 2232 ELSE QbeGen.SetBit(sq, qe,
|
|
|
+ 2233 lo, span)
|
|
|
+ 2234 END
|
|
|
+ 2235 END; .) .
|
|
|
+ 2236 GetIdent<VAR n: SymTab.Name>
|
|
|
+ 2237 = ident (. LexName(n); .) .
|
|
|
+ 2238
|
|
|
+ 2239 END M2.
|
|
|
|
|
|
0 errors
|
|
|
|
