|
|
@@ -517,3400 +517,3401 @@ Listing:
|
|
|
499 (* intrinsic C library:
|
|
|
500 permissive external *)
|
|
|
501 IF NOT SymTab.DeclareCProc(n) THEN
|
|
|
- 502 SemError(201) END
|
|
|
- 503 ELSIF SymTab.ModKnown(mod)
|
|
|
- 504 AND NOT SymTab.ImportFrom(mod, n) THEN
|
|
|
- 505 SemError(201) END; .)
|
|
|
- 506 | ( "TSIZE" | "SIZE" | "ADR" | "HIGH" | "LEN"
|
|
|
- 507 | "CHR" | "ORD" | "ORDL" | "VAL" | "ABS" | "CAP"
|
|
|
- 508 | "UCHR" | "CHR8" | "UORD"
|
|
|
- 509 | "INC" | "DEC" ) .
|
|
|
- 510 ImpModList<node: AST.Node> (. VAR n: SymTab.Name; .)
|
|
|
- 511 = GetIdent<n> (. AST.SetChild(node, AST.NChild(node),
|
|
|
- 512 AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
- 513 { "," GetIdent<n> (. AST.SetChild(node, AST.NChild(node),
|
|
|
- 514 AST.MakeLeaf(AST.NkIdent, n)); .) } .
|
|
|
- 515 (* Opaque TYPE declarations (definition modules). The targetless
|
|
|
- 516 alias resolves to InvalidType until step 4 completes it. *)
|
|
|
- 517 (* Scalar-phase TYPEs: named types, integer subranges, enumerations.
|
|
|
- 518 Opaque "TYPE T;" needs isDef (definition units); elsewhere 231.
|
|
|
- 519 Composite forms (ARRAY/RECORD/SET/POINTER) arrive with step 3. *)
|
|
|
- 520 TypeBlock<isDef: BOOLEAN> (. VAR astSeq, astTail: AST.Node; .)
|
|
|
- 521 = "TYPE" (. SymTab.BeginTypeBlock;
|
|
|
- 522 astSeq := AST.NoNode;
|
|
|
- 523 astTail := AST.NoNode; .)
|
|
|
- 524 { (. astDecl := AST.NoNode; .)
|
|
|
- 525 ( TypeItem<isDef> ";" | ClassItem ";" )
|
|
|
- 526 (. AstAppend(AST.NkDeclSeq,
|
|
|
- 527 astSeq, astTail, astDecl); .) }
|
|
|
- 528 (. SymTab.EndTypeBlock;
|
|
|
- 529 astDecl := astSeq; .) .
|
|
|
- 530 TypeItem<isDef: BOOLEAN> (. VAR n: SymTab.Name;
|
|
|
- 531 t, op: SymTab.TypeIndex;
|
|
|
- 532 astNode: AST.Node; .)
|
|
|
- 533 = GetIdent<n> (. op := SymTab.OpaqueBase(n);
|
|
|
- 534 IF op = SymTab.InvalidType THEN
|
|
|
- 535 IF NOT SymTab.Enter(n,
|
|
|
- 536 SymTab.KindType) THEN
|
|
|
- 537 SemError(200) END
|
|
|
- 538 END; .)
|
|
|
- 539 ( "=" Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkTypeDecl);
|
|
|
- 540 AST.SetChild(astNode, 0,
|
|
|
- 541 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
- 542 AST.SetTy(astNode, t);
|
|
|
- 543 astDecl := astNode;
|
|
|
- 544 IF op # SymTab.InvalidType THEN
|
|
|
- 545 SymTab.SetTarget(op, t)
|
|
|
- 546 ELSE SymTab.SetSymType(n, t)
|
|
|
- 547 END; .)
|
|
|
- 548 | (. IF op # SymTab.InvalidType THEN
|
|
|
- 549 (* stays opaque *)
|
|
|
- 550 ELSIF NOT isDef THEN
|
|
|
- 551 SemError(231)
|
|
|
- 552 ELSE SymTab.SetSymType(n,
|
|
|
- 553 SymTab.NewAlias()) END; .) ) .
|
|
|
- 554 Type<VAR t: SymTab.TypeIndex; allowOpen: BOOLEAN>
|
|
|
- 555 = TypeIdent<t> [ Subrange<t> ] (* anchored subrange: T[lo..hi] *)
|
|
|
- 556 | Subrange<t>
|
|
|
- 557 | Enum<t>
|
|
|
- 558 | ArrayType<t, allowOpen>
|
|
|
- 559 | SetType<t>
|
|
|
- 560 | RecordType<t>
|
|
|
- 561 | PointerType<t>
|
|
|
- 562 | ProcType<t> .
|
|
|
- 563 PointerType<VAR t: SymTab.TypeIndex> (. VAR base: SymTab.TypeIndex; .)
|
|
|
- 564 = "POINTER" "TO" Type<base, FALSE>(. t := SymTab.NewPtr(base); .) .
|
|
|
- 565 (* Procedure types (step 8.5): PROCEDURE (params): result. Values
|
|
|
- 566 are code pointers; params are collected into the descriptor. *)
|
|
|
- 567 ProcType<VAR t: SymTab.TypeIndex> (. VAR res, pt: SymTab.TypeIndex;
|
|
|
- 568 isV: BOOLEAN; .)
|
|
|
- 569 = "PROCEDURE" (. res := SymTab.InvalidType;
|
|
|
- 570 t := SymTab.NewProcType(res); .)
|
|
|
- 571 [ "(" [ ProcTypeSection<t> { ";" ProcTypeSection<t> } ] ")" ]
|
|
|
- 572 [ ":" TypeIdent<res> (. SymTab.SetProcTypeRes(t, res); .) ] .
|
|
|
- 573 ProcTypeSection<t: SymTab.TypeIndex> (. VAR pt: SymTab.TypeIndex;
|
|
|
- 574 isV: BOOLEAN;
|
|
|
- 575 cnt, k: CARDINAL;
|
|
|
- 576 names: ARRAY [0 .. 15] OF SymTab.Name; .)
|
|
|
- 577 = (. isV := FALSE; cnt := 0; .)
|
|
|
- 578 [ "VAR" (. isV := TRUE; .) ]
|
|
|
- 579 ( GetIdent<names[cnt]> (. INC(cnt); .)
|
|
|
- 580 { "," GetIdent<names[cnt]> (. INC(cnt); .) }
|
|
|
- 581 ( ":" Type<pt, TRUE> (. k := 0;
|
|
|
- 582 WHILE k < cnt DO
|
|
|
- 583 SymTab.ProcTypeAdd(t, isV, pt);
|
|
|
- 584 INC(k)
|
|
|
- 585 END; .)
|
|
|
- 586 | (. (* type-only parameter list:
|
|
|
- 587 each name is a type (GNU
|
|
|
- 588 shorthand used by the
|
|
|
- 589 Coco/R scanner frame) *)
|
|
|
- 590 k := 0;
|
|
|
- 591 WHILE k < cnt DO
|
|
|
- 592 IF SymTab.Lookup(names[k])
|
|
|
- 593 AND ((SymTab.SymKind(names[k]) = SymTab.KindType)
|
|
|
- 594 OR (SymTab.SymKind(names[k]) = SymTab.KindPredef)) THEN
|
|
|
- 595 pt := SymTab.SymType(names[k])
|
|
|
- 596 ELSE SemError(201);
|
|
|
- 597 pt := SymTab.InvalidType
|
|
|
- 598 END;
|
|
|
- 599 SymTab.ProcTypeAdd(t, isV, pt);
|
|
|
- 600 INC(k)
|
|
|
- 601 END; .) )
|
|
|
- 602 | Type<pt, TRUE> (. (* unnamed parameter (PIM):
|
|
|
- 603 e.g. PROCEDURE (VAR ARRAY OF REAL) *)
|
|
|
- 604 SymTab.ProcTypeAdd(t, isV, pt); .) ) .
|
|
|
- 605 (* Arrays: "OF" without bounds is an open formal (allowed only
|
|
|
- 606 where allowOpen); "[lo..hi, ...]" nests bounded levels inside
|
|
|
- 607 out. Bounds are folded literals (int/char); anything else 230.
|
|
|
- 608 Bare-type indices ("ARRAY Color OF") wait for enum ordinals. *)
|
|
|
- 609 ArrayType<VAR t: SymTab.TypeIndex; allowOpen: BOOLEAN>
|
|
|
- 610 (. VAR elem: SymTab.TypeIndex;
|
|
|
- 611 ok: BOOLEAN;
|
|
|
- 612 bnds, bndh: ARRAY [0 .. 7] OF INTEGER;
|
|
|
- 613 nb, k: CARDINAL;
|
|
|
- 614 idx: SymTab.TypeIndex;
|
|
|
- 615 ilo, ihi: INTEGER; .)
|
|
|
- 616 = "ARRAY"
|
|
|
- 617 ( "OF" Type<elem, FALSE> (. IF NOT allowOpen THEN
|
|
|
- 618 SemError(230) END;
|
|
|
- 619 t := SymTab.NewOpenArray(elem); .)
|
|
|
- 620 | TypeIdent<idx> [ Subrange<idx> ]
|
|
|
- 621 "OF" Type<elem, FALSE> (. (* index-type array: the index
|
|
|
- 622 type's ordinal bounds give the
|
|
|
- 623 [lo..hi] pair *)
|
|
|
- 624 IF SymTab.TypeBounds(idx, ilo,
|
|
|
- 625 ihi)
|
|
|
- 626 THEN t := SymTab.NewArrayB(elem,
|
|
|
- 627 ilo, ihi)
|
|
|
- 628 ELSE SemError(230);
|
|
|
- 629 t := SymTab.InvalidType
|
|
|
- 630 END; .)
|
|
|
- 631 | "[" (. SymTab.BoundBegin; ok := TRUE; .)
|
|
|
- 632 BoundPair<ok>
|
|
|
- 633 { "," BoundPair<ok> }
|
|
|
- 634 "]" (. (* snapshot before the element
|
|
|
- 635 type, which reuses the bound
|
|
|
- 636 buffer for a nested ARRAY *)
|
|
|
- 637 nb := SymTab.BoundCount();
|
|
|
- 638 k := 0;
|
|
|
- 639 WHILE k < nb DO
|
|
|
- 640 bnds[k] := SymTab.BoundLo(k);
|
|
|
- 641 bndh[k] := SymTab.BoundHi(k);
|
|
|
- 642 INC(k)
|
|
|
- 643 END; .)
|
|
|
- 644 "OF" Type<elem, FALSE>
|
|
|
- 645 (. IF ok THEN
|
|
|
- 646 k := nb;
|
|
|
- 647 WHILE k > 0 DO
|
|
|
- 648 DEC(k);
|
|
|
- 649 elem := SymTab.NewArrayB(
|
|
|
- 650 elem, bnds[k], bndh[k])
|
|
|
- 651 END;
|
|
|
- 652 t := elem
|
|
|
- 653 ELSE t := SymTab.InvalidType
|
|
|
- 654 END; .) ) .
|
|
|
- 655 BoundPair<VAR ok: BOOLEAN> (. VAR tlo, thi: SymTab.TypeIndex;
|
|
|
- 656 qlo, qhi: QbeGen.QVal;
|
|
|
- 657 lo, hi: INTEGER;
|
|
|
- 658 cl, cl2: INTEGER; .)
|
|
|
- 659 = Expr<tlo, qlo> ".." Expr<thi, qhi>
|
|
|
- 660 (. IF (tlo = SymTab.InvalidType)
|
|
|
- 661 OR (thi = SymTab.InvalidType) THEN
|
|
|
- 662 ok := FALSE
|
|
|
- 663 ELSE cl := SymTab.ClassOf(tlo);
|
|
|
- 664 cl2 := SymTab.ClassOf(thi);
|
|
|
- 665 IF ((cl # SymTab.ClInt)
|
|
|
- 666 AND (cl # SymTab.ClChar))
|
|
|
- 667 OR ((cl2 # SymTab.ClInt)
|
|
|
- 668 AND (cl2 # SymTab.ClChar)) THEN
|
|
|
- 669 SemError(230); ok := FALSE
|
|
|
- 670 ELSIF NOT SymTab.ConstInt(qlo, lo)
|
|
|
- 671 OR NOT SymTab.ConstInt(qhi, hi)
|
|
|
- 672 OR (lo > hi) THEN
|
|
|
- 673 SemError(230); ok := FALSE
|
|
|
- 674 ELSIF NOT SymTab.BoundAdd(lo, hi) THEN
|
|
|
- 675 SemError(230); ok := FALSE
|
|
|
- 676 END;
|
|
|
- 677 END; .) .
|
|
|
- 678 (* Sets: multi-word masks over bases ≤ 256 values (bool, char,
|
|
|
- 679 bounded subranges; enums wait for ordinals, INTEGER is
|
|
|
- 680 unbounded). Literals are SET OF [0..255]; assignment and
|
|
|
- 681 comparison across suitable bases are lenient (masks over min
|
|
|
- 682 words + zero-check extras), out-of-span literals are 222. *)
|
|
|
- 683 SetType<VAR t: SymTab.TypeIndex> (. VAR base: SymTab.TypeIndex;
|
|
|
- 684 blo, bhi, bspan: INTEGER;
|
|
|
- 685 bcls: INTEGER; .)
|
|
|
- 686 = "SET" "OF" Type<base, FALSE>
|
|
|
- 687 (. IF base = SymTab.InvalidType THEN
|
|
|
- 688 t := SymTab.InvalidType
|
|
|
- 689 ELSE bcls :=
|
|
|
- 690 SymTab.ClassOf(base);
|
|
|
- 691 IF bcls = SymTab.ClBool THEN
|
|
|
- 692 blo := 0; bspan := 2
|
|
|
- 693 ELSIF bcls = SymTab.ClChar THEN
|
|
|
- 694 blo := 0; bspan := 256
|
|
|
- 695 ELSIF bcls = SymTab.ClEnum THEN
|
|
|
- 696 blo := 0;
|
|
|
- 697 bspan := VAL(INTEGER,
|
|
|
- 698 SymTab.EnumCount(base))
|
|
|
- 699 ELSIF SymTab.SubBounds(base,
|
|
|
- 700 blo, bhi) THEN
|
|
|
- 701 bspan := bhi - blo + 1
|
|
|
- 702 ELSE bspan := 0 END;
|
|
|
- 703 IF (bspan <= 0)
|
|
|
- 704 OR (bspan > 65536) THEN
|
|
|
- 705 SemError(230);
|
|
|
- 706 t := SymTab.InvalidType
|
|
|
- 707 ELSE t := SymTab.NewSet(base)
|
|
|
- 708 END
|
|
|
- 709 END; .) .
|
|
|
- 710 (* Records: flat blobs; array fields are pointers to static
|
|
|
- 711 descriptors (locked amendment), nested records inline. Field
|
|
|
- 712 offsets static and declaration-ordered. *)
|
|
|
- 713 (* Field list: plain fields and (optionally) one variant part. The
|
|
|
- 714 variant part is a `CASE ... END` item; because it starts with the
|
|
|
- 715 CASE keyword it is unambiguously distinguishable from a field
|
|
|
- 716 (which starts with an identifier). *)
|
|
|
- 717 RecordType<VAR t: SymTab.TypeIndex> (. VAR t2: SymTab.TypeIndex;
|
|
|
- 718 tagOk: BOOLEAN; .)
|
|
|
- 719 = "RECORD" (. t := SymTab.NewRecord(); .)
|
|
|
- 720 [ RecItem<t> { ";" [ RecItem<t> ] } ]
|
|
|
- 721 "END" .
|
|
|
- 722 RecItem<rec: SymTab.TypeIndex> (. VAR tt: SymTab.TypeIndex; .)
|
|
|
- 723 = RecField<rec>
|
|
|
- 724 | CaseField<rec> (. SymTab.MarkVariant(rec); .) .
|
|
|
- 725 (* A variant part: CASE tag : Type OF variants. The layout overlays
|
|
|
- 726 every branch from the tag slot (see SymTab.ComputeOffsets). *)
|
|
|
- 727 CaseField<rec: SymTab.TypeIndex> (. VAR tagT: SymTab.TypeIndex;
|
|
|
- 728 tagN: SymTab.Name; .)
|
|
|
- 729 = "CASE" (. SymTab.ResetFields(rec); .)
|
|
|
- 730 GetIdent<tagN> (. IF NOT SymTab.FieldPending(rec,
|
|
|
- 731 tagN) THEN
|
|
|
- 732 SemError(200) END; .)
|
|
|
- 733 ":" Type<tagT, FALSE> (. IF (tagT # SymTab.InvalidType)
|
|
|
- 734 AND NOT SymTab.IsOrdinal(tagT) THEN
|
|
|
- 735 SemError(224)
|
|
|
- 736 END;
|
|
|
- 737 SymTab.FixPendingF(rec, tagT);
|
|
|
- 738 SymTab.SetVariantTag(rec, tagN); .)
|
|
|
- 739 "OF"
|
|
|
- 740 RecFieldList<rec>
|
|
|
- 741 { "|" (. SymTab.ResetFields(rec); .)
|
|
|
- 742 RecFieldList<rec> }
|
|
|
- 743 "END" .
|
|
|
- 744 RecFieldList<rec: SymTab.TypeIndex> (. VAR lt, lq: SymTab.TypeIndex;
|
|
|
- 745 lv1, lv2: QbeGen.QVal; .)
|
|
|
- 746 = VarLabel<lt, lv1> [ ".." VarLabel<lq, lv2> ] ":"
|
|
|
- 747 RecField<rec> { ";" [ RecField<rec> ] } .
|
|
|
- 748 (* Variant case label: a constant (or a constant range). Values are
|
|
|
- 749 not interpreted (the layout overlays regardless). *)
|
|
|
- 750 VarLabel<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 751 (. VAR lname: SymTab.Name; .)
|
|
|
- 752 = ( ident (. LexName(lname);
|
|
|
- 753 QbeGen.CopyOp("0", q);
|
|
|
- 754 t := SymTab.IntType(); .)
|
|
|
- 755 | integer (. LexString(lname);
|
|
|
- 756 QbeGen.CopyOp("0", q);
|
|
|
- 757 t := SymTab.IntType(); .)
|
|
|
- 758 | charConst (. LexString(lname);
|
|
|
- 759 QbeGen.CopyOp("0", q);
|
|
|
- 760 t := SymTab.CharType(); .) ) .
|
|
|
- 761 RecField<rec: SymTab.TypeIndex> (. VAR n: SymTab.Name;
|
|
|
- 762 t2: SymTab.TypeIndex; .)
|
|
|
- 763 = RecIdents<rec> ":" Type<t2, FALSE>(. SymTab.FixPendingF(rec, t2); .) .
|
|
|
- 764 RecIdents<rec: SymTab.TypeIndex> (. VAR n: SymTab.Name; .)
|
|
|
- 765 = GetIdent<n> (. IF NOT SymTab.FieldPending(rec,
|
|
|
- 766 n) THEN
|
|
|
- 767 SemError(200) END; .)
|
|
|
- 768 { "," GetIdent<n> (. IF NOT SymTab.FieldPending(rec,
|
|
|
- 769 n) THEN
|
|
|
- 770 SemError(200) END; .) } .
|
|
|
- 771 TypeIdent<VAR t: SymTab.TypeIndex> (. VAR n, qid: SymTab.Name;
|
|
|
- 772 k: INTEGER;
|
|
|
- 773 dotted: BOOLEAN; .)
|
|
|
- 774 = GetIdent<n> (. dotted := FALSE;
|
|
|
- 775 IF NOT SymTab.Lookup(n) THEN
|
|
|
- 776 k := -1;
|
|
|
- 777 t := SymTab.ForwardType(n);
|
|
|
- 778 IF t = SymTab.InvalidType THEN
|
|
|
- 779 SemError(201)
|
|
|
- 780 END
|
|
|
- 781 ELSE k := SymTab.SymKind(n);
|
|
|
- 782 IF (k = SymTab.KindType)
|
|
|
- 783 OR (k = SymTab.KindPredef) THEN
|
|
|
- 784 t := SymTab.SymType(n)
|
|
|
- 785 ELSE t := SymTab.InvalidType
|
|
|
- 786 END
|
|
|
- 787 END; .)
|
|
|
- 788 [ "." GetIdent<qid> (. dotted := TRUE;
|
|
|
- 789 IF k = SymTab.KindModule THEN
|
|
|
- 790 t := SymTab.QualType(n, qid);
|
|
|
- 791 IF t = SymTab.InvalidType THEN
|
|
|
- 792 SemError(201)
|
|
|
- 793 END
|
|
|
- 794 ELSE SemError(221);
|
|
|
- 795 t := SymTab.InvalidType
|
|
|
- 796 END; .) ]
|
|
|
- 797 (. IF NOT dotted THEN
|
|
|
- 798 IF (k = SymTab.KindModule)
|
|
|
- 799 OR ((k # SymTab.KindType)
|
|
|
- 800 AND (k # SymTab.KindPredef)
|
|
|
- 801 AND (k # SymTab.KindImport)
|
|
|
- 802 AND (k # -1)) THEN
|
|
|
- 803 SemError(221)
|
|
|
- 804 END
|
|
|
- 805 END; .) .
|
|
|
- 806 Subrange<VAR t: SymTab.TypeIndex> (. VAR tlo, thi: SymTab.TypeIndex;
|
|
|
- 807 qlo, qhi: QbeGen.QVal;
|
|
|
- 808 lo, hi: INTEGER; .)
|
|
|
- 809 = "[" Expr<tlo, qlo> ".." Expr<thi, qhi>
|
|
|
- 810 (. IF (tlo = SymTab.InvalidType)
|
|
|
- 811 OR (thi = SymTab.InvalidType) THEN
|
|
|
- 812 t := SymTab.InvalidType
|
|
|
- 813 ELSIF NOT SymTab.IsOrdinal(tlo)
|
|
|
- 814 OR NOT SymTab.IsOrdinal(thi) THEN
|
|
|
- 815 SemError(230);
|
|
|
- 816 t := SymTab.InvalidType
|
|
|
- 817 ELSIF NOT SymTab.ConstInt(qlo, lo)
|
|
|
- 818 OR NOT SymTab.ConstInt(qhi, hi)
|
|
|
- 819 OR (lo > hi) THEN
|
|
|
- 820 SemError(230);
|
|
|
- 821 t := SymTab.InvalidType
|
|
|
- 822 ELSE t := SymTab.NewSubR(lo, hi)
|
|
|
- 823 END; .)
|
|
|
- 824 "]" .
|
|
|
- 825 Enum<VAR t: SymTab.TypeIndex> (. VAR n: SymTab.Name;
|
|
|
- 826 ord: INTEGER;
|
|
|
- 827 qv: QbeGen.QVal; .)
|
|
|
- 828 = "(" (. t := SymTab.NewEnum();
|
|
|
- 829 ord := 0; .)
|
|
|
- 830 GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
- 831 SymTab.KindConst) THEN
|
|
|
- 832 SemError(200) END;
|
|
|
- 833 SymTab.SetSymType(n, t);
|
|
|
- 834 QbeGen.IntStr(ord, qv);
|
|
|
- 835 SymTab.SetSymVal(n, qv);
|
|
|
- 836 Lower.NoteVar(n,
|
|
|
- 837 SymTab.KindConst, t);
|
|
|
- 838 Lower.NoteConstVal(qv);
|
|
|
- 839 INC(ord); .)
|
|
|
- 840 { "," GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
- 841 SymTab.KindConst) THEN
|
|
|
- 842 SemError(200) END;
|
|
|
- 843 SymTab.SetSymType(n, t);
|
|
|
- 844 QbeGen.IntStr(ord, qv);
|
|
|
- 845 SymTab.SetSymVal(n, qv);
|
|
|
- 846 Lower.NoteVar(n,
|
|
|
- 847 SymTab.KindConst, t);
|
|
|
- 848 Lower.NoteConstVal(qv);
|
|
|
- 849 INC(ord); .) }
|
|
|
- 850 ")" (. SymTab.SetEnumCount(t,
|
|
|
- 851 VAL(CARDINAL, ord)); .) .
|
|
|
- 852 (* Clarion-form classes (docs/OOP.txt): declaration + single
|
|
|
- 853 inheritance + IMPLEMENTATION blocks. Scopes and member checks
|
|
|
- 854 now; lowering (vtable, dispatch, THIS) later — one 230 per
|
|
|
- 855 class/impl block. Methods end with ";" per the Table example
|
|
|
- 856 (not "," as in the sketch). No underscores in identifiers. *)
|
|
|
- 857 (* Single CLASS item in both loops: separating declaration from
|
|
|
- 858 IMPLEMENTATION at the loop level needs 2-token lookahead
|
|
|
- 859 (CLASS ident vs CLASS IMPLEMENTATION), which LL(1) cannot do.
|
|
|
- 860 The second token decides after CLASS is consumed. A misplaced
|
|
|
- 861 CLASS IMPLEMENTATION inside TYPE still parses (harmless: the
|
|
|
- 862 whole unit ends 230 until lowering). *)
|
|
|
- 863 ClassItem
|
|
|
- 864 = "CLASS" ( "IMPLEMENTATION" ClassImplRest | ClassRest ) .
|
|
|
- 865 ClassRest (. VAR cn, m2, pn: SymTab.Name;
|
|
|
- 866 ct: SymTab.TypeIndex; .)
|
|
|
- 867 = GetIdent<cn> (. IF NOT SymTab.Enter(cn,
|
|
|
- 868 SymTab.KindType) THEN
|
|
|
- 869 SemError(200) END;
|
|
|
- 870 ct := SymTab.NewClass();
|
|
|
- 871 SymTab.SetSymType(cn, ct);
|
|
|
- 872 SymTab.PushClassScope(ct);
|
|
|
- 873 astCls := AST.MakeNode(AST.NkClassDecl);
|
|
|
- 874 AST.SetChild(astCls, 0,
|
|
|
- 875 AST.MakeLeaf(AST.NkIdent, cn));
|
|
|
- 876 astClsP := AST.NoNode;
|
|
|
- 877 astClsPTail := AST.NoNode;
|
|
|
- 878 astClsF := AST.NoNode;
|
|
|
- 879 astClsFTail := AST.NoNode;
|
|
|
- 880 astClsM := AST.NoNode;
|
|
|
- 881 astClsMTail := AST.NoNode; .)
|
|
|
- 882 [ Parents<ct> ]
|
|
|
- 883 ";"
|
|
|
- 884 { ClassField<ct> ";" }
|
|
|
- 885 { MethodHeading<pn, SymTab.InvalidType> ";"
|
|
|
- 886 (. Lower.ScopeLeave;
|
|
|
- 887 SymTab.CloseProc;
|
|
|
- 888 QbeGen.AbortFunc; .) }
|
|
|
- 889 "END"
|
|
|
- 890 GetIdent<m2> (. IF NOT SymTab.Equal(cn, m2) THEN
|
|
|
- 891 SemError(202) END;
|
|
|
- 892 SymTab.LayoutClass(ct);
|
|
|
- 893 SymTab.PopScope;
|
|
|
- 894 AST.SetChild(astCls, 1, astClsP);
|
|
|
- 895 AST.SetChild(astCls, 2, astClsF);
|
|
|
- 896 AST.SetChild(astCls, 3, astClsM);
|
|
|
- 897 astDecl := astCls; .) .
|
|
|
- 898 Parents<ct: SymTab.TypeIndex> (. VAR p: SymTab.Name; .)
|
|
|
- 899 = "(" Parent1<ct>
|
|
|
- 900 { "," GetIdent<p> (. SemError(230); .) }
|
|
|
- 901 ")" .
|
|
|
- 902 Parent1<ct: SymTab.TypeIndex> (. VAR p: SymTab.Name;
|
|
|
- 903 pt: SymTab.TypeIndex; .)
|
|
|
- 904 = GetIdent<p> (. IF NOT SymTab.Lookup(p) THEN
|
|
|
- 905 SemError(201)
|
|
|
- 906 ELSE pt := SymTab.SymType(p);
|
|
|
- 907 IF SymTab.ClassOf(pt) #
|
|
|
- 908 SymTab.ClClass THEN
|
|
|
- 909 SemError(230)
|
|
|
- 910 ELSE SymTab.SetParent(ct, pt)
|
|
|
- 911 END
|
|
|
- 912 END;
|
|
|
- 913 AstAppend(AST.NkFieldDecl,
|
|
|
- 914 astClsP, astClsPTail,
|
|
|
- 915 AST.MakeLeaf(AST.NkIdent, p)); .) .
|
|
|
- 916 ClassField<ct: SymTab.TypeIndex> (. VAR n, rhs: SymTab.Name;
|
|
|
- 917 t: SymTab.TypeIndex;
|
|
|
- 918 astNode: AST.Node; .)
|
|
|
- 919 = GetIdent<n>
|
|
|
- 920 ( "=" GetIdent<rhs> (. IF NOT SymTab.Enter(n,
|
|
|
- 921 SymTab.KindConst) THEN
|
|
|
- 922 SemError(200) END;
|
|
|
- 923 astNode := AST.MakeNode(AST.NkConstDecl);
|
|
|
- 924 AST.SetChild(astNode, 0,
|
|
|
- 925 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
- 926 AST.SetChild(astNode, 1,
|
|
|
- 927 AST.MakeLeaf(AST.NkIdent, rhs));
|
|
|
- 928 AstAppend(AST.NkFieldDecl,
|
|
|
- 929 astClsF, astClsFTail, astNode);
|
|
|
- 930 IF SymTab.Lookup(rhs) THEN
|
|
|
- 931 SymTab.SetSymType(n,
|
|
|
- 932 SymTab.SymType(rhs))
|
|
|
- 933 END; .)
|
|
|
- 934 | (. IF NOT SymTab.FieldPending(ct,
|
|
|
- 935 n) THEN
|
|
|
- 936 SemError(200) END;
|
|
|
- 937 astNode := AST.MakeNode(AST.NkVarDecl);
|
|
|
- 938 AST.SetChild(astNode, 0,
|
|
|
- 939 AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
- 940 { "," GetIdent<n> (. IF NOT SymTab.FieldPending(ct,
|
|
|
- 941 n) THEN
|
|
|
- 942 SemError(200) END;
|
|
|
- 943 AST.SetChild(astNode,
|
|
|
- 944 AST.NChild(astNode),
|
|
|
- 945 AST.MakeLeaf(AST.NkIdent, n)); .) }
|
|
|
- 946 ":" Type<t, FALSE> (. SymTab.FixPendingF(ct, t);
|
|
|
- 947 AST.SetTy(astNode, t);
|
|
|
- 948 AstAppend(AST.NkFieldDecl,
|
|
|
- 949 astClsF, astClsFTail, astNode); .) ) .
|
|
|
- 950 MethodHeading<VAR pn: SymTab.Name; ct: SymTab.TypeIndex>
|
|
|
- 951 (. VAR wantVirt: BOOLEAN; .)
|
|
|
- 952 = (. wantVirt := FALSE; .)
|
|
|
- 953 [ "VIRTUAL" (. wantVirt := TRUE; .) ]
|
|
|
- 954 ProcHeading<pn, ct> (. IF wantVirt THEN
|
|
|
- 955 SymTab.MarkVirtual END;
|
|
|
- 956 astMethod := AST.MakeNode(AST.NkProcDecl);
|
|
|
- 957 AST.SetChild(astMethod, 0,
|
|
|
- 958 AST.MakeLeaf(AST.NkIdent, pn));
|
|
|
- 959 IF wantVirt THEN
|
|
|
- 960 AST.SetOp(astMethod, 3)
|
|
|
- 961 ELSE AST.SetOp(astMethod, 0)
|
|
|
- 962 END;
|
|
|
- 963 AstAppend(AST.NkFieldDecl,
|
|
|
- 964 astClsM, astClsMTail, astMethod); .) .
|
|
|
- 965 ClassImplRest (. VAR cn, m2: SymTab.Name;
|
|
|
- 966 ct: SymTab.TypeIndex; .)
|
|
|
- 967 = GetIdent<cn> (. IF NOT SymTab.Lookup(cn) THEN
|
|
|
- 968 SemError(201);
|
|
|
- 969 ct := SymTab.InvalidType
|
|
|
- 970 ELSE ct := SymTab.SymType(cn);
|
|
|
- 971 IF SymTab.ClassOf(ct) #
|
|
|
- 972 SymTab.ClClass THEN
|
|
|
- 973 SemError(230);
|
|
|
- 974 ct := SymTab.InvalidType
|
|
|
- 975 END
|
|
|
- 976 END;
|
|
|
- 977 astCls := AST.MakeNode(AST.NkClassDecl);
|
|
|
- 978 AST.SetOp(astCls, 1);
|
|
|
- 979 AST.SetChild(astCls, 0,
|
|
|
- 980 AST.MakeLeaf(AST.NkIdent, cn));
|
|
|
- 981 astClsM := AST.NoNode;
|
|
|
- 982 astClsMTail := AST.NoNode;
|
|
|
- 983 astStmt := AST.NoNode;
|
|
|
- 984 IF ct #
|
|
|
- 985 SymTab.InvalidType THEN
|
|
|
- 986 IF NOT SymTab.PushClassMembers(
|
|
|
- 987 ct) THEN
|
|
|
- 988 SemError(230) END;
|
|
|
- 989 SymTab.PushImplClass(ct)
|
|
|
- 990 END; .)
|
|
|
- 991 ";" { MethodImpl<ct> ";" }
|
|
|
- 992 (. astStmt := AST.NoNode; .)
|
|
|
- 993 [ "BEGIN" (. astStmt := AST.MakeNode(AST.NkBlock);
|
|
|
- 994 QbeGen.BeginInit(cn); .)
|
|
|
- 995 [ StatSeq ] (. QbeGen.EndInit; .) ]
|
|
|
- 996 "END"
|
|
|
- 997 GetIdent<m2> (. IF NOT SymTab.Equal(cn, m2) THEN
|
|
|
- 998 SemError(202) END;
|
|
|
- 999 SymTab.PopImplClass;
|
|
|
- 1000 SymTab.PopScope;
|
|
|
- 1001 AST.SetChild(astCls, 1, AST.NoNode);
|
|
|
- 1002 AST.SetChild(astCls, 2, astStmt);
|
|
|
- 1003 AST.SetChild(astCls, 3, astClsM);
|
|
|
- 1004 astDecl := astCls; .) .
|
|
|
- 1005 MethodImpl<ct: SymTab.TypeIndex> (. VAR pn: SymTab.Name;
|
|
|
- 1006 thisQ: QbeGen.QVal;
|
|
|
- 1007 methRes: SymTab.TypeIndex; .)
|
|
|
- 1008 = MethodHeading<pn, ct> ";"
|
|
|
- 1009 (. IF (ct #
|
|
|
- 1010 SymTab.InvalidType)
|
|
|
- 1011 AND NOT SymTab.MethodExists(ct,
|
|
|
- 1012 pn) THEN
|
|
|
- 1013 SemError(201) END; .)
|
|
|
- 1014 ( "FORWARD" (. AST.SetOp(astMethod, 1);
|
|
|
- 1015 SymTab.MarkFwd;
|
|
|
- 1016 QbeGen.AbortFunc;
|
|
|
- 1017 Lower.ScopeLeave;
|
|
|
- 1018 SymTab.CloseProc; .)
|
|
|
- 1019 | (. QbeGen.EndFuncHeader;
|
|
|
- 1020 (* bind the receiver: bare
|
|
|
- 1021 field names resolve
|
|
|
- 1022 against THIS *)
|
|
|
- 1023 QbeGen.ThisBase(thisQ);
|
|
|
- 1024 QbeGen.PushWith(thisQ); .)
|
|
|
- 1025 Block<pn> (. AST.SetChild(astMethod, 1, astStmt);
|
|
|
- 1026 QbeGen.PopWith;
|
|
|
- 1027 methRes := SymTab.CurRes();
|
|
|
- 1028 Lower.ScopeLeave;
|
|
|
- 1029 SymTab.CloseProc;
|
|
|
- 1030 QbeGen.EndFunc(methRes); .) ) .
|
|
|
- 1031 ConstBlock (. VAR astSeq, astTail: AST.Node; .)
|
|
|
- 1032 = "CONST" (. astSeq := AST.NoNode;
|
|
|
- 1033 astTail := AST.NoNode; .)
|
|
|
- 1034 { ConstDecl ";" (. AstAppend(AST.NkDeclSeq,
|
|
|
- 1035 astSeq, astTail, astDecl); .) }
|
|
|
- 1036 (. astDecl := astSeq; .) .
|
|
|
- 1037 ConstDecl (. VAR n: SymTab.Name;
|
|
|
- 1038 t: SymTab.TypeIndex;
|
|
|
- 1039 qv: QbeGen.QVal;
|
|
|
- 1040 cls: INTEGER;
|
|
|
- 1041 astNode: AST.Node; .)
|
|
|
- 1042 = GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
- 1043 SymTab.KindConst) THEN
|
|
|
- 1044 SemError(200) END; .)
|
|
|
- 1045 "="
|
|
|
- 1046 Expr<t, qv> (. astNode := AST.MakeNode(AST.NkConstDecl);
|
|
|
- 1047 AST.SetChild(astNode, 0,
|
|
|
- 1048 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
- 1049 AST.SetChild(astNode, 1, astCur);
|
|
|
- 1050 AST.SetTy(astNode, t);
|
|
|
- 1051 astDecl := astNode;
|
|
|
- 1052 Lower.NoteVar(n, SymTab.KindConst, t);
|
|
|
- 1053 Lower.NoteConstVal(qv);
|
|
|
- 1054 SymTab.SetSymType(n, t);
|
|
|
- 1055 cls := SymTab.ClassOf(t);
|
|
|
- 1056 IF (cls = SymTab.ClArray)
|
|
|
- 1057 OR (cls = SymTab.ClRecord)
|
|
|
- 1058 OR (cls = SymTab.ClClass)
|
|
|
- 1059 OR (cls = SymTab.ClStr)
|
|
|
- 1060 OR (cls = SymTab.ClUStr) THEN
|
|
|
- 1061 (* an aggregate/string
|
|
|
- 1062 constant: qv is its
|
|
|
- 1063 descriptor address; no
|
|
|
- 1064 scalar data *)
|
|
|
- 1065 SymTab.SetSymVal(n, qv)
|
|
|
- 1066 ELSIF NOT QbeGen.IsImm(qv) THEN
|
|
|
- 1067 SemError(230)
|
|
|
- 1068 ELSE
|
|
|
- 1069 SymTab.SetSymVal(n, qv);
|
|
|
- 1070 QbeGen.DeclConst(n, qv, t)
|
|
|
- 1071 END; .) .
|
|
|
- 1072 VarBlock (. VAR astSeq, astTail: AST.Node; .)
|
|
|
- 1073 = "VAR" (. astSeq := AST.NoNode;
|
|
|
- 1074 astTail := AST.NoNode; .)
|
|
|
- 1075 { VarDecl ";" (. AstAppend(AST.NkDeclSeq,
|
|
|
- 1076 astSeq, astTail, astDecl); .) }
|
|
|
- 1077 (. astDecl := astSeq; .) .
|
|
|
- 1078 VarDecl (. VAR nm: SymTab.Name;
|
|
|
- 1079 t: SymTab.TypeIndex;
|
|
|
- 1080 i: CARDINAL;
|
|
|
- 1081 cls: INTEGER;
|
|
|
- 1082 astNode, astTail: AST.Node; .)
|
|
|
- 1083 = VarIdents ":"
|
|
|
- 1084 Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkVarDecl);
|
|
|
- 1085 astTail := astNode;
|
|
|
- 1086 i := 0;
|
|
|
- 1087 WHILE i < SymTab.PendCount() DO
|
|
|
- 1088 SymTab.PendName(i, nm);
|
|
|
- 1089 Lower.NoteVar(nm, SymTab.KindVar, t);
|
|
|
- 1090 (* chunked: a VAR list can
|
|
|
- 1091 exceed AST.MaxChild *)
|
|
|
- 1092 AstAppend(AST.NkBlock,
|
|
|
- 1093 astNode, astTail,
|
|
|
- 1094 AST.MakeLeaf(AST.NkIdent, nm));
|
|
|
- 1095 INC(i)
|
|
|
- 1096 END;
|
|
|
- 1097 AST.SetTy(astNode, t);
|
|
|
- 1098 astDecl := astNode;
|
|
|
- 1099 cls := SymTab.ClassOf(t);
|
|
|
- 1100 IF (t # SymTab.InvalidType)
|
|
|
- 1101 AND NOT SymTab.IsUnresolved(t)
|
|
|
- 1102 AND (cls # SymTab.ClInt)
|
|
|
- 1103 AND (cls # SymTab.ClBool)
|
|
|
- 1104 AND (cls # SymTab.ClChar)
|
|
|
- 1105 AND (cls # SymTab.ClReal)
|
|
|
- 1106 AND (cls # SymTab.ClArray)
|
|
|
- 1107 AND (cls # SymTab.ClSet)
|
|
|
- 1108 AND (cls # SymTab.ClRecord)
|
|
|
- 1109 AND (cls # SymTab.ClPtr)
|
|
|
- 1110 AND (cls # SymTab.ClLong)
|
|
|
- 1111 AND (cls # SymTab.ClProc)
|
|
|
- 1112 AND (cls # SymTab.ClUChar)
|
|
|
- 1113 AND (cls # SymTab.ClUStr)
|
|
|
- 1114 AND (cls # SymTab.ClEnum)
|
|
|
- 1115 AND (cls # SymTab.ClClass) THEN
|
|
|
- 1116 SemError(230) END;
|
|
|
- 1117 IF QbeGen.LocFull() THEN
|
|
|
- 1118 SemError(233) END;
|
|
|
- 1119 i := 0;
|
|
|
- 1120 IF SymTab.IsUnresolved(t)
|
|
|
- 1121 AND NOT SymTab.InProc() THEN
|
|
|
- 1122 (* a forward-typed global:
|
|
|
- 1123 defer emission until the
|
|
|
- 1124 TYPE block completes *)
|
|
|
- 1125 WHILE i < SymTab.PendCount() DO
|
|
|
- 1126 SymTab.PendName(i, nm);
|
|
|
- 1127 IF nPendVar <=
|
|
|
- 1128 HIGH(pendVarName) THEN
|
|
|
- 1129 pendVarName[nPendVar] := nm;
|
|
|
- 1130 pendVarT[nPendVar] := t;
|
|
|
- 1131 INC(nPendVar)
|
|
|
- 1132 END;
|
|
|
- 1133 INC(i)
|
|
|
- 1134 END
|
|
|
- 1135 ELSE
|
|
|
- 1136 WHILE i < SymTab.PendCount() DO
|
|
|
- 1137 SymTab.PendName(i, nm);
|
|
|
- 1138 QbeGen.DeclVar(nm, t);
|
|
|
- 1139 INC(i)
|
|
|
- 1140 END
|
|
|
- 1141 END;
|
|
|
- 1142 (* a plain VAR list, not a
|
|
|
- 1143 heading: the signature
|
|
|
- 1144 result is discarded *)
|
|
|
- 1145 IF NOT SymTab.FixPending(t) THEN
|
|
|
- 1146 END; .) .
|
|
|
- 1147 VarIdents (. VAR n: SymTab.Name; .)
|
|
|
- 1148 = GetIdent<n> (. IF NOT SymTab.EnterPending(n,
|
|
|
- 1149 SymTab.KindVar) THEN
|
|
|
- 1150 SemError(200) END; .)
|
|
|
- 1151 { ","
|
|
|
- 1152 GetIdent<n> (. IF NOT SymTab.EnterPending(n,
|
|
|
- 1153 SymTab.KindVar) THEN
|
|
|
- 1154 SemError(200) END; .) } .
|
|
|
- 1155 ParIdents<isV: BOOLEAN> (. VAR n: SymTab.Name; .)
|
|
|
- 1156 = GetIdent<n> (. IF NOT SymTab.EnterParam(n, isV) THEN
|
|
|
- 1157 SemError(200) END; .)
|
|
|
- 1158 { "," GetIdent<n> (. IF NOT SymTab.EnterParam(n, isV) THEN
|
|
|
- 1159 SemError(200) END; .) } .
|
|
|
- 1160 (* Procedure headings enter scopes/params/result and buffer the
|
|
|
- 1161 QBE header; bodies lower to functions (4.1, module level only).
|
|
|
- 1162 FORWARD marks; the body heading re-enters (signature compare
|
|
|
- 1163 deferred). Nested procedures parse + check, lowering = 4.2. *)
|
|
|
- 1164 ProcHeading<VAR pn: SymTab.Name; methCls: SymTab.TypeIndex>
|
|
|
- 1165 (. VAR t: SymTab.TypeIndex;
|
|
|
- 1166 mg: QbeGen.QVal; .)
|
|
|
- 1167 = "PROCEDURE"
|
|
|
- 1168 GetIdent<pn> (. IF methCls #
|
|
|
- 1169 SymTab.InvalidType THEN
|
|
|
- 1170 (* a method: resume the
|
|
|
- 1171 declared symbol (reuse
|
|
|
- 1172 its uid) *)
|
|
|
- 1173 IF NOT SymTab.ResumeMethod(
|
|
|
- 1174 methCls, pn) THEN
|
|
|
- 1175 SemError(200) END
|
|
|
- 1176 ELSIF NOT SymTab.EnterProc(pn) THEN
|
|
|
- 1177 IF NOT SymTab.ReenterProc(pn) THEN
|
|
|
- 1178 IF NOT SymTab.ResumeProc(pn) THEN
|
|
|
- 1179 SemError(200) END
|
|
|
- 1180 END
|
|
|
- 1181 END;
|
|
|
- 1182 Lower.ScopeEnter;
|
|
|
- 1183 Lower.NoteProc(pn,
|
|
|
- 1184 SymTab.ProcUid(pn),
|
|
|
- 1185 SymTab.InvalidType,
|
|
|
- 1186 SymTab.ProcDepthOf(pn),
|
|
|
- 1187 FALSE);
|
|
|
- 1188 IF methCls #
|
|
|
- 1189 SymTab.InvalidType THEN
|
|
|
- 1190 QbeGen.Mangled(pn,
|
|
|
- 1191 SymTab.MethUid(), mg)
|
|
|
- 1192 ELSE
|
|
|
- 1193 QbeGen.Mangled(pn,
|
|
|
- 1194 SymTab.ProcUid(pn), mg)
|
|
|
- 1195 END;
|
|
|
- 1196 QbeGen.BeginFunc(mg);
|
|
|
- 1197 IF methCls #
|
|
|
- 1198 SymTab.InvalidType THEN
|
|
|
- 1199 (* hidden THIS receiver:
|
|
|
- 1200 a VAR param of the
|
|
|
- 1201 class type, pushed as
|
|
|
- 1202 the WITH base *)
|
|
|
- 1203 IF NOT SymTab.EnterThisParam(
|
|
|
- 1204 methCls) THEN
|
|
|
- 1205 SemError(200) END;
|
|
|
- 1206 IF NOT QbeGen.FuncParam(
|
|
|
- 1207 "THIS", TRUE,
|
|
|
- 1208 methCls) THEN
|
|
|
- 1209 SemError(233) END
|
|
|
- 1210 END; .)
|
|
|
- 1211 [ FormalParams ]
|
|
|
- 1212 [ ":" TypeIdent<t> (. IF NOT SymTab.SetProcRes(t) THEN
|
|
|
- 1213 SemError(235) END;
|
|
|
- 1214 Lower.SetProcRes(t);
|
|
|
- 1215 QbeGen.SetFuncRes(t);
|
|
|
- 1216 IF (t #
|
|
|
- 1217 SymTab.InvalidType)
|
|
|
- 1218 AND ((SymTab.ClassOf(t)
|
|
|
- 1219 = SymTab.ClArray)
|
|
|
- 1220 OR (SymTab.ClassOf(t)
|
|
|
- 1221 = SymTab.ClRecord)
|
|
|
- 1222 OR (SymTab.ClassOf(t)
|
|
|
- 1223 = SymTab.ClSet)
|
|
|
- 1224 OR (SymTab.ClassOf(t)
|
|
|
- 1225 = SymTab.ClClass)) THEN
|
|
|
- 1226 SemError(230) END; .) ] .
|
|
|
- 1227 FormalParams
|
|
|
- 1228 = "(" [ ParamSection { ";" ParamSection } ] ")" .
|
|
|
- 1229 ParamSection (. VAR t: SymTab.TypeIndex;
|
|
|
- 1230 nm: SymTab.Name;
|
|
|
- 1231 i: CARDINAL;
|
|
|
- 1232 isV: BOOLEAN; .)
|
|
|
- 1233 = (. isV := FALSE; .)
|
|
|
- 1234 [ "VAR" (. isV := TRUE; .) ]
|
|
|
- 1235 ParIdents<isV> ":" Type<t, TRUE> (. i := 0;
|
|
|
- 1236 WHILE i < SymTab.PendCount() DO
|
|
|
- 1237 SymTab.PendName(i, nm);
|
|
|
- 1238 Lower.NoteParam(nm, t, isV);
|
|
|
- 1239 Lower.NoteVar(nm, SymTab.KindParam, t);
|
|
|
- 1240 (* value open arrays are
|
|
|
- 1241 passed as descriptor
|
|
|
- 1242 addresses (no copy):
|
|
|
- 1243 same representation as
|
|
|
- 1244 VAR formals *)
|
|
|
- 1245 IF NOT QbeGen.FuncParam(nm,
|
|
|
- 1246 isV
|
|
|
- 1247 OR SymTab.IsOpenArray(t),
|
|
|
- 1248 t) THEN
|
|
|
- 1249 SemError(233) END;
|
|
|
- 1250 INC(i)
|
|
|
- 1251 END;
|
|
|
- 1252 IF NOT SymTab.FixPending(t) THEN
|
|
|
- 1253 SemError(235) END; .) .
|
|
|
- 1254 (* Nested procedures lower like top-level ones (4.2): the
|
|
|
- 1255 static link gives them their parent's frame. Methods keep
|
|
|
- 1256 parse-now/230-later. *)
|
|
|
- 1257 ProcDecl (. VAR pn: SymTab.Name;
|
|
|
- 1258 astNode: AST.Node; .)
|
|
|
- 1259 = ProcHeading<pn, SymTab.InvalidType> ";"
|
|
|
- 1260 (. astNode := AST.MakeNode(AST.NkProcDecl);
|
|
|
- 1261 AST.SetOp(astNode, 0);
|
|
|
- 1262 AST.SetChild(astNode, 0,
|
|
|
- 1263 AST.MakeLeaf(AST.NkIdent, pn));
|
|
|
- 1264 Lower.NoteProcNode(astNode); .)
|
|
|
- 1265 ( "FORWARD" (. AST.SetOp(astNode, 1);
|
|
|
- 1266 astDecl := astNode;
|
|
|
- 1267 Lower.ScopeLeave;
|
|
|
- 1268 SymTab.MarkFwd;
|
|
|
- 1269 SymTab.CloseProc;
|
|
|
- 1270 QbeGen.AbortFunc; .)
|
|
|
- 1271 | "EXTERNAL" (. AST.SetOp(astNode, 2);
|
|
|
- 1272 astDecl := astNode;
|
|
|
- 1273 Lower.MarkProcExternal;
|
|
|
- 1274 Lower.ScopeLeave;
|
|
|
- 1275 SymTab.MarkExternal("");
|
|
|
- 1276 SymTab.CloseProc;
|
|
|
- 1277 QbeGen.AbortFunc; .)
|
|
|
- 1278 | (. QbeGen.EndFuncHeader; .)
|
|
|
- 1279 Block<pn> (. AST.SetChild(astNode, 1, astStmt);
|
|
|
- 1280 AST.SetChild(astNode, 2, astBlkDecls);
|
|
|
- 1281 astDecl := astNode;
|
|
|
- 1282 Lower.ScopeLeave;
|
|
|
- 1283 SymTab.CloseProc;
|
|
|
- 1284 QbeGen.EndFunc(
|
|
|
- 1285 SymTab.ProcRes(pn)); .) ) .
|
|
|
- 1286 Block<pn: SymTab.Name> (. VAR m2: SymTab.Name; .)
|
|
|
- 1287 = DeclSeq (. astBlkDecls := astDecl;
|
|
|
- 1288 astStmt := AST.NoNode; .)
|
|
|
- 1289 [ "BEGIN" (. (* an empty body is still a
|
|
|
- 1290 body: mark it so Lower
|
|
|
- 1291 does not read it as a
|
|
|
- 1292 definition heading *)
|
|
|
- 1293 IF astStmt = AST.NoNode THEN
|
|
|
- 1294 astStmt :=
|
|
|
- 1295 AST.MakeNode(AST.NkBlock)
|
|
|
- 1296 END; .)
|
|
|
- 1297 [ StatSeq ] ]
|
|
|
- 1298 "END"
|
|
|
- 1299 GetIdent<m2> (. IF NOT SymTab.Equal(pn, m2) THEN
|
|
|
- 1300 SemError(202) END; .) .
|
|
|
- 1301 StatSeq (. VAR astSeq, astTail: AST.Node; .)
|
|
|
- 1302 = (. astSeq := AST.NoNode;
|
|
|
- 1303 astTail := AST.NoNode; .)
|
|
|
- 1304 Statement (. AstAppend(AST.NkBlock,
|
|
|
- 1305 astSeq, astTail, astStmt); .)
|
|
|
- 1306 { ";" [ Statement (. AstAppend(AST.NkBlock,
|
|
|
- 1307 astSeq, astTail, astStmt); .) ] }
|
|
|
- 1308 (. astStmt := astSeq; .) .
|
|
|
- 1309 (* Trailing/empty statements (`a; ; b`, Coco/R's generated `;;`)
|
|
|
- 1310 are accepted: the statement after ';' is optional. *)
|
|
|
- 1311 Statement (. VAR lx: QbeGen.QVal; .)
|
|
|
- 1312 = (. astStmt := AST.NoNode; .)
|
|
|
- 1313 ( AssOrCall
|
|
|
- 1314 | IfStat
|
|
|
- 1315 | WhileStat
|
|
|
- 1316 | RepeatStat
|
|
|
- 1317 | LoopStat
|
|
|
- 1318 | ForStat
|
|
|
- 1319 | CaseStat
|
|
|
- 1320 | WithStat
|
|
|
- 1321 | ReturnStat
|
|
|
- 1322 | HaltStat
|
|
|
- 1323 | NewStat
|
|
|
- 1324 | DisposeStat
|
|
|
- 1325 | IncDecStat
|
|
|
- 1326 | InclExclStat
|
|
|
- 1327 | "EXIT" (. IF QbeGen.TopLoop(lx) THEN
|
|
|
- 1328 QbeGen.Jmp(lx)
|
|
|
- 1329 ELSE SemError(230) END;
|
|
|
- 1330 astStmt := AST.MakeNode(AST.NkExit); .) ) .
|
|
|
- 1331 (* INCL(set, elem) / EXCL(set, elem): PIM set-element builtins. *)
|
|
|
- 1332 InclExclStat (. VAR at, et2: SymTab.TypeIndex;
|
|
|
- 1333 dk: INTEGER;
|
|
|
- 1334 qd, qe: QbeGen.QVal;
|
|
|
- 1335 qn: SymTab.Name;
|
|
|
- 1336 sfx, isInc: BOOLEAN;
|
|
|
- 1337 astNode, astD: AST.Node; .)
|
|
|
- 1338 = ( "INCL" (. isInc := TRUE; .)
|
|
|
- 1339 | "EXCL" (. isInc := FALSE; .) )
|
|
|
- 1340 "(" Design<at, dk, qd, qn, sfx> (. astD := astCur; .) ","
|
|
|
- 1341 Expr<et2, qe> ")"
|
|
|
- 1342 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 1343 IF isInc THEN
|
|
|
- 1344 AST.SetChild(astNode, 0,
|
|
|
- 1345 AST.MakeLeaf(AST.NkIdent, "INCL"))
|
|
|
- 1346 ELSE AST.SetChild(astNode, 0,
|
|
|
- 1347 AST.MakeLeaf(AST.NkIdent, "EXCL"))
|
|
|
- 1348 END;
|
|
|
- 1349 IF astD # AST.NoNode THEN
|
|
|
- 1350 AST.SetChild(astNode, 1, astD) END;
|
|
|
- 1351 IF astCur # AST.NoNode THEN
|
|
|
- 1352 AST.SetChild(astNode, 2, astCur) END;
|
|
|
- 1353 astStmt := astNode; .)
|
|
|
- 1354 (. IF at = SymTab.InvalidType THEN
|
|
|
- 1355 ELSIF SymTab.ClassOf(at) #
|
|
|
- 1356 SymTab.ClSet THEN
|
|
|
- 1357 SemError(222)
|
|
|
- 1358 ELSE
|
|
|
- 1359 IF isInc THEN
|
|
|
- 1360 QbeGen.SetBit(qd, qe,
|
|
|
- 1361 SymTab.SetBaseLo(at),
|
|
|
- 1362 SymTab.SetCount(at))
|
|
|
- 1363 ELSE
|
|
|
- 1364 QbeGen.SetClearBit(qd, qe,
|
|
|
- 1365 SymTab.SetBaseLo(at),
|
|
|
- 1366 SymTab.SetCount(at))
|
|
|
- 1367 END
|
|
|
- 1368 END; .) .
|
|
|
- 1369 (* INC(v [,step]) / DEC(v [,step]) as builtin statements over an
|
|
|
- 1370 integer designator. *)
|
|
|
- 1371 IncDecStat (. VAR dt, et2: SymTab.TypeIndex;
|
|
|
- 1372 dk: INTEGER;
|
|
|
- 1373 qd, qv, qn2, qstep:
|
|
|
- 1374 QbeGen.QVal;
|
|
|
- 1375 qn: SymTab.Name;
|
|
|
- 1376 sfx, isInc: BOOLEAN;
|
|
|
- 1377 astNode, astD, astStep:
|
|
|
- 1378 AST.Node; .)
|
|
|
- 1379 = (. isInc := TRUE; .)
|
|
|
- 1380 ( "INC" (. isInc := TRUE; .)
|
|
|
- 1381 | "DEC" (. isInc := FALSE; .) )
|
|
|
- 1382 "(" (. QbeGen.CopyOp("1", qstep); astStep := AST.NoNode; .)
|
|
|
- 1383 Design<dt, dk, qd, qn, sfx> (. astD := astCur; .)
|
|
|
- 1384 [ "," Expr<et2, qstep> (. astStep := astCur; .) ]
|
|
|
- 1385 ")" (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 1386 IF isInc THEN
|
|
|
- 1387 AST.SetChild(astNode, 0,
|
|
|
- 1388 AST.MakeLeaf(AST.NkIdent, "INC"))
|
|
|
- 1389 ELSE AST.SetChild(astNode, 0,
|
|
|
- 1390 AST.MakeLeaf(AST.NkIdent, "DEC"))
|
|
|
- 1391 END;
|
|
|
- 1392 IF astD # AST.NoNode THEN
|
|
|
- 1393 AST.SetChild(astNode, 1, astD) END;
|
|
|
- 1394 IF astStep # AST.NoNode THEN
|
|
|
- 1395 AST.SetChild(astNode, 2, astStep) END;
|
|
|
- 1396 astStmt := astNode; .) (. IF dt = SymTab.InvalidType THEN
|
|
|
- 1397 ELSIF (dk # SymTab.KindVar)
|
|
|
- 1398 AND (dk # SymTab.KindParam)
|
|
|
- 1399 AND (dk # SymTab.KindField) THEN
|
|
|
- 1400 SemError(210)
|
|
|
- 1401 ELSIF NOT SymTab.IsIntFamily(dt) THEN
|
|
|
- 1402 SemError(211)
|
|
|
- 1403 ELSE
|
|
|
- 1404 IF sfx
|
|
|
- 1405 OR (dk = SymTab.KindField) THEN
|
|
|
- 1406 QbeGen.ElemLoad(qd, dt, qv)
|
|
|
- 1407 ELSE QbeGen.LoadVar(qn,
|
|
|
- 1408 FALSE, qv)
|
|
|
- 1409 END;
|
|
|
- 1410 QbeGen.NewTemp(qn2);
|
|
|
- 1411 IF isInc THEN
|
|
|
- 1412 QbeGen.Op3("add", qn2, qv,
|
|
|
- 1413 qstep, FALSE)
|
|
|
- 1414 ELSE QbeGen.Op3("sub", qn2, qv,
|
|
|
- 1415 qstep, FALSE)
|
|
|
- 1416 END;
|
|
|
- 1417 IF sfx
|
|
|
- 1418 OR (dk = SymTab.KindField) THEN
|
|
|
- 1419 QbeGen.ElemStore(qd, qn2,
|
|
|
- 1420 dt)
|
|
|
- 1421 ELSE QbeGen.StoreVar(qn,
|
|
|
- 1422 qn2, FALSE)
|
|
|
- 1423 END
|
|
|
- 1424 END; .) .
|
|
|
- 1425 (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
|
|
|
- 1426 Targets are pointer designators; DISPOSE nils afterwards (safer
|
|
|
- 1427 than Wirth-undefined; documented). DISPOSE is shallow. *)
|
|
|
- 1428 NewStat (. VAR dt: SymTab.TypeIndex;
|
|
|
- 1429 dk: INTEGER;
|
|
|
- 1430 qd, qm: QbeGen.QVal;
|
|
|
- 1431 qn: SymTab.Name;
|
|
|
- 1432 sfx: BOOLEAN;
|
|
|
- 1433 bt: SymTab.TypeIndex;
|
|
|
- 1434 astNode, astD: AST.Node; .)
|
|
|
- 1435 = "NEW" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
|
|
|
- 1436 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 1437 AST.SetChild(astNode, 0,
|
|
|
- 1438 AST.MakeLeaf(AST.NkIdent, "NEW"));
|
|
|
- 1439 IF astD # AST.NoNode THEN
|
|
|
- 1440 AST.SetChild(astNode, 1, astD) END;
|
|
|
- 1441 astStmt := astNode; .)
|
|
|
- 1442 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 1443 ELSIF (dk # SymTab.KindVar)
|
|
|
- 1444 AND (dk # SymTab.KindParam)
|
|
|
- 1445 AND (dk # SymTab.KindField) THEN
|
|
|
- 1446 SemError(210)
|
|
|
- 1447 ELSIF SymTab.ClassOf(dt) #
|
|
|
- 1448 SymTab.ClPtr THEN
|
|
|
- 1449 SemError(219)
|
|
|
- 1450 ELSE bt := SymTab.PtrBase(dt);
|
|
|
- 1451 IF bt #
|
|
|
- 1452 SymTab.InvalidType THEN
|
|
|
- 1453 QbeGen.NewHeap(bt, qm);
|
|
|
- 1454 QbeGen.InitHeap(qm, bt);
|
|
|
- 1455 IF sfx
|
|
|
- 1456 OR (dk =
|
|
|
- 1457 SymTab.KindField) THEN
|
|
|
- 1458 QbeGen.ElemStore(qd, qm,
|
|
|
- 1459 dt)
|
|
|
- 1460 ELSE QbeGen.StorePtr(qn,
|
|
|
- 1461 qm)
|
|
|
- 1462 END
|
|
|
- 1463 END
|
|
|
- 1464 END; .) .
|
|
|
- 1465 DisposeStat (. VAR dt: SymTab.TypeIndex;
|
|
|
- 1466 dk: INTEGER;
|
|
|
- 1467 qd, qv: QbeGen.QVal;
|
|
|
- 1468 qn: SymTab.Name;
|
|
|
- 1469 sfx: BOOLEAN;
|
|
|
- 1470 astNode, astD: AST.Node; .)
|
|
|
- 1471 = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
|
|
|
- 1472 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 1473 AST.SetChild(astNode, 0,
|
|
|
- 1474 AST.MakeLeaf(AST.NkIdent, "DISPOSE"));
|
|
|
- 1475 IF astD # AST.NoNode THEN
|
|
|
- 1476 AST.SetChild(astNode, 1, astD) END;
|
|
|
- 1477 astStmt := astNode; .)
|
|
|
- 1478 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 1479 ELSIF (dk # SymTab.KindVar)
|
|
|
- 1480 AND (dk # SymTab.KindParam)
|
|
|
- 1481 AND (dk # SymTab.KindField) THEN
|
|
|
- 1482 SemError(210)
|
|
|
- 1483 ELSIF SymTab.ClassOf(dt) #
|
|
|
- 1484 SymTab.ClPtr THEN
|
|
|
- 1485 SemError(219)
|
|
|
- 1486 ELSE
|
|
|
- 1487 IF sfx
|
|
|
- 1488 OR (dk =
|
|
|
- 1489 SymTab.KindField) THEN
|
|
|
- 1490 QbeGen.ElemLoad(qd, dt,
|
|
|
- 1491 qv)
|
|
|
- 1492 ELSE QbeGen.LoadPtr(qn, qv)
|
|
|
- 1493 END;
|
|
|
- 1494 QbeGen.FreeHeap(qv);
|
|
|
- 1495 IF sfx
|
|
|
- 1496 OR (dk =
|
|
|
- 1497 SymTab.KindField) THEN
|
|
|
- 1498 QbeGen.ElemStore(qd, "0",
|
|
|
- 1499 dt)
|
|
|
- 1500 ELSE QbeGen.StorePtr(qn,
|
|
|
- 1501 "0")
|
|
|
- 1502 END
|
|
|
- 1503 END; .) .
|
|
|
- 1504 (* WITH pushes each record's fields (inner wins) plus its base
|
|
|
- 1505 address; field designators resolve through both stacks. *)
|
|
|
- 1506 WithStat (. VAR nW: CARDINAL;
|
|
|
- 1507 astNode: AST.Node; .)
|
|
|
- 1508 = "WITH" (. nW := 0;
|
|
|
- 1509 astNode := AST.MakeNode(AST.NkWith); .)
|
|
|
- 1510 WithItem<nW, astNode> { "," WithItem<nW, astNode> }
|
|
|
- 1511 "DO" (. astStmt := AST.NoNode; .)
|
|
|
- 1512 [ StatSeq ] "END" (. AST.SetChild(astNode,
|
|
|
- 1513 AST.NChild(astNode), astStmt);
|
|
|
- 1514 astStmt := astNode;
|
|
|
- 1515 WHILE nW > 0 DO
|
|
|
- 1516 SymTab.PopScope;
|
|
|
- 1517 QbeGen.PopWith;
|
|
|
- 1518 DEC(nW)
|
|
|
- 1519 END; .) .
|
|
|
- 1520 WithItem<VAR nW: CARDINAL; wnode: AST.Node>
|
|
|
- 1521 (. VAR dt: SymTab.TypeIndex;
|
|
|
- 1522 dk: INTEGER;
|
|
|
- 1523 qd, qe: QbeGen.QVal;
|
|
|
- 1524 qn: SymTab.Name;
|
|
|
- 1525 sfx: BOOLEAN; .)
|
|
|
- 1526 = Design<dt, dk, qd, qn, sfx>
|
|
|
- 1527 (. IF astCur # AST.NoNode THEN
|
|
|
- 1528 AST.SetChild(wnode,
|
|
|
- 1529 AST.NChild(wnode), astCur) END;
|
|
|
- 1530 IF dt = SymTab.InvalidType THEN
|
|
|
- 1531 ELSIF (SymTab.ClassOf(dt) #
|
|
|
- 1532 SymTab.ClRecord)
|
|
|
- 1533 AND (SymTab.ClassOf(dt) #
|
|
|
- 1534 SymTab.ClClass) THEN
|
|
|
- 1535 SemError(215)
|
|
|
- 1536 ELSIF SymTab.PushRecord(dt) THEN
|
|
|
- 1537 QbeGen.PushWith(qd);
|
|
|
- 1538 INC(nW)
|
|
|
- 1539 END; .) .
|
|
|
- 1540 (* Assignment or procedure-statement call (4.1, module level).
|
|
|
- 1541 Bare `P;` is a syntax error; function-as-statement is 233. *)
|
|
|
- 1542 AssOrCall (. VAR dt, et: SymTab.TypeIndex;
|
|
|
- 1543 dk: INTEGER;
|
|
|
- 1544 qd, qe, qt, ql: QbeGen.QVal;
|
|
|
- 1545 qn: SymTab.Name;
|
|
|
- 1546 ct2, res0: SymTab.TypeIndex;
|
|
|
- 1547 q2, mg0: QbeGen.QVal;
|
|
|
- 1548 isR, conv, wconv: BOOLEAN;
|
|
|
- 1549 called, sfx: BOOLEAN;
|
|
|
- 1550 astLhs: AST.Node; .)
|
|
|
- 1551 = Design<dt, dk, qd, qn, sfx>
|
|
|
- 1552 (. astLhs := astCur; astNArgs := 0; .)
|
|
|
- 1553 ( ":="
|
|
|
- 1554 Expr<et, qe> (. astStmt := AST.MakeBin(
|
|
|
- 1555 AST.NkAssign, 0, astLhs, astCur);
|
|
|
- 1556 IF (dt # SymTab.InvalidType)
|
|
|
- 1557 AND (dk # SymTab.KindVar)
|
|
|
- 1558 AND (dk # SymTab.KindParam)
|
|
|
- 1559 AND (dk # SymTab.KindField) THEN
|
|
|
- 1560 SemError(210)
|
|
|
- 1561 ELSIF NOT SymTab.Assignable(et,
|
|
|
- 1562 dt) THEN
|
|
|
- 1563 SemError(210)
|
|
|
- 1564 ELSIF (dt # SymTab.InvalidType)
|
|
|
- 1565 AND (SymTab.ClassOf(dt) =
|
|
|
- 1566 SymTab.ClClass) THEN
|
|
|
- 1567 SemError(230) END;
|
|
|
- 1568 isR := (dt #
|
|
|
- 1569 SymTab.InvalidType)
|
|
|
- 1570 AND (SymTab.ClassOf(dt)
|
|
|
- 1571 = SymTab.ClReal);
|
|
|
- 1572 conv := isR
|
|
|
- 1573 AND SymTab.IsIntFamily(et);
|
|
|
- 1574 wconv := (dt #
|
|
|
- 1575 SymTab.InvalidType)
|
|
|
- 1576 AND SymTab.IsLongFamily(dt)
|
|
|
- 1577 AND SymTab.IsIntFamily(et);
|
|
|
- 1578 IF ((dk = SymTab.KindVar)
|
|
|
- 1579 OR (dk = SymTab.KindParam)
|
|
|
- 1580 OR (dk = SymTab.KindField))
|
|
|
- 1581 AND (dt # SymTab.InvalidType)
|
|
|
- 1582 AND (et # SymTab.InvalidType)
|
|
|
- 1583 AND (SymTab.ClassOf(dt) #
|
|
|
- 1584 SymTab.ClClass) THEN
|
|
|
- 1585 IF sfx
|
|
|
- 1586 OR (dk = SymTab.KindField) THEN
|
|
|
- 1587 IF SymTab.ClassOf(dt) =
|
|
|
- 1588 SymTab.ClArray THEN
|
|
|
- 1589 IF (et # SymTab.InvalidType)
|
|
|
- 1590 AND (SymTab.ClassOf(et) = SymTab.ClUStr)
|
|
|
- 1591 AND SymTab.IsUCharArray(dt) THEN
|
|
|
- 1592 QbeGen.UAssign(qd, qe)
|
|
|
- 1593 ELSIF SymTab.StrCompat(dt,
|
|
|
- 1594 et) THEN
|
|
|
- 1595 QbeGen.StrAssign(qd,
|
|
|
- 1596 qe)
|
|
|
- 1597 ELSE
|
|
|
- 1598 QbeGen.CopyArray(qd,
|
|
|
- 1599 qe, dt)
|
|
|
- 1600 END
|
|
|
- 1601 ELSIF SymTab.ClassOf(dt) =
|
|
|
- 1602 SymTab.ClSet THEN
|
|
|
- 1603 QbeGen.CopySet(qd, qe,
|
|
|
- 1604 SymTab.SetWords(dt),
|
|
|
- 1605 SymTab.SetWords(et))
|
|
|
- 1606 ELSIF SymTab.ClassOf(dt) =
|
|
|
- 1607 SymTab.ClRecord THEN
|
|
|
- 1608 QbeGen.CopyRecord(qd, qe,
|
|
|
- 1609 dt)
|
|
|
- 1610 ELSIF SymTab.IsLongFamily(dt) THEN
|
|
|
- 1611 IF wconv THEN
|
|
|
- 1612 QbeGen.WidenLong(qe, ql);
|
|
|
- 1613 QbeGen.ElemStore(qd, ql,
|
|
|
- 1614 dt)
|
|
|
- 1615 ELSE QbeGen.ElemStore(qd, qe,
|
|
|
- 1616 dt)
|
|
|
- 1617 END
|
|
|
- 1618 ELSIF conv THEN
|
|
|
- 1619 QbeGen.ConvIR(qe, qt);
|
|
|
- 1620 QbeGen.ElemStore(qd, qt,
|
|
|
- 1621 dt)
|
|
|
- 1622 ELSE QbeGen.ElemStore(qd, qe,
|
|
|
- 1623 dt)
|
|
|
- 1624 END
|
|
|
- 1625 ELSIF SymTab.ClassOf(dt) =
|
|
|
- 1626 SymTab.ClArray THEN
|
|
|
- 1627 IF (et # SymTab.InvalidType)
|
|
|
- 1628 AND (SymTab.ClassOf(et) = SymTab.ClUStr)
|
|
|
- 1629 AND SymTab.IsUCharArray(dt) THEN
|
|
|
- 1630 QbeGen.UAssign(qd, qe)
|
|
|
- 1631 ELSIF SymTab.StrCompat(dt,
|
|
|
- 1632 et) THEN
|
|
|
- 1633 QbeGen.StrAssign(qd, qe)
|
|
|
- 1634 ELSE
|
|
|
- 1635 QbeGen.CopyArray(qd, qe,
|
|
|
- 1636 dt)
|
|
|
- 1637 END
|
|
|
- 1638 ELSIF SymTab.ClassOf(dt) =
|
|
|
- 1639 SymTab.ClSet THEN
|
|
|
- 1640 QbeGen.CopySet(qd, qe,
|
|
|
- 1641 SymTab.SetWords(dt),
|
|
|
- 1642 SymTab.SetWords(et))
|
|
|
- 1643 ELSIF SymTab.ClassOf(dt) =
|
|
|
- 1644 SymTab.ClRecord THEN
|
|
|
- 1645 QbeGen.CopyRecord(qd, qe, dt)
|
|
|
- 1646 ELSIF (SymTab.ClassOf(dt) =
|
|
|
- 1647 SymTab.ClPtr)
|
|
|
- 1648 OR (SymTab.ClassOf(dt) =
|
|
|
- 1649 SymTab.ClProc) THEN
|
|
|
- 1650 QbeGen.StorePtr(qn, qe)
|
|
|
- 1651 ELSIF SymTab.IsLongFamily(dt) THEN
|
|
|
- 1652 IF wconv THEN
|
|
|
- 1653 QbeGen.WidenLong(qe, ql);
|
|
|
- 1654 QbeGen.StoreLong(qn, ql)
|
|
|
- 1655 ELSE QbeGen.StoreLong(qn, qe)
|
|
|
- 1656 END
|
|
|
- 1657 ELSIF conv THEN
|
|
|
- 1658 QbeGen.ConvIR(qe, qt);
|
|
|
- 1659 QbeGen.StoreVar(qn, qt, TRUE)
|
|
|
- 1660 ELSE
|
|
|
- 1661 QbeGen.StoreVar(qn, qe, isR)
|
|
|
- 1662 END
|
|
|
- 1663 END; .)
|
|
|
- 1664 | ArgList<qn, dt, qd, FALSE, FALSE, methCls, ct2, q2, called>
|
|
|
- 1665 (. astStmt := AstCallNode(astLhs); .)
|
|
|
- 1666 | (* bare `P;`: proper parameterless
|
|
|
- 1667 procedure call; anything else
|
|
|
- 1668 here is 233 (was a bare syntax
|
|
|
- 1669 error before 4.2) *)
|
|
|
- 1670 (. astStmt := AstCallNode(astLhs);
|
|
|
- 1671 IF (dk = SymTab.KindProc)
|
|
|
- 1672 AND NOT sfx THEN
|
|
|
- 1673 res0 := SymTab.ProcRes(qn);
|
|
|
- 1674 IF res0 #
|
|
|
- 1675 SymTab.InvalidType THEN
|
|
|
- 1676 SemError(233)
|
|
|
- 1677 ELSIF SymTab.ProcNPar(qn) #
|
|
|
- 1678 0 THEN
|
|
|
- 1679 SemError(233)
|
|
|
- 1680 ELSE QbeGen.Mangled(qn,
|
|
|
- 1681 SymTab.ProcUid(qn), mg0);
|
|
|
- 1682 QbeGen.CallBegin(mg0,
|
|
|
- 1683 res0,
|
|
|
- 1684 SymTab.ProcDepthOf(qn),
|
|
|
- 1685 SymTab.IsExternal(qn));
|
|
|
- 1686 QbeGen.CallEnd(FALSE, q2)
|
|
|
- 1687 END
|
|
|
- 1688 ELSE SemError(233)
|
|
|
- 1689 END; .) ) .
|
|
|
- 1690 (* Actual-parameter list shared by statement and expression calls.
|
|
|
- 1691 want selects CallEnd's result handling; t/q carry the call
|
|
|
- 1692 value (statement calls discard). Arity/type failures are 233;
|
|
|
- 1693 evaluation code still emits so the .ssa stays assembleable. *)
|
|
|
- 1694 ArgList<pn: SymTab.Name; pt: SymTab.TypeIndex; callee: QbeGen.QVal;
|
|
|
- 1695 want: BOOLEAN; soft: BOOLEAN; methCls: SymTab.TypeIndex;
|
|
|
- 1696 VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
|
|
|
- 1697 VAR called: BOOLEAN> (. VAR i, np: CARDINAL;
|
|
|
- 1698 vs: INTEGER;
|
|
|
- 1699 res: SymTab.TypeIndex;
|
|
|
- 1700 mg: QbeGen.QVal;
|
|
|
- 1701 ok, ind, isMeth, va: BOOLEAN; .)
|
|
|
- 1702 = "(" (. called := TRUE;
|
|
|
- 1703 ok := TRUE;
|
|
|
- 1704 ind := FALSE;
|
|
|
- 1705 isMeth := methCls #
|
|
|
- 1706 SymTab.InvalidType;
|
|
|
- 1707 IF isMeth THEN
|
|
|
- 1708 (* class method: the
|
|
|
- 1709 receiver is armed.
|
|
|
- 1710 Virtual -> dispatch
|
|
|
- 1711 through the vtable;
|
|
|
- 1712 otherwise a static
|
|
|
- 1713 call. *)
|
|
|
- 1714 res := SymTab.ClassMethodRes(
|
|
|
- 1715 methCls, pn);
|
|
|
- 1716 vs := SymTab.VirtSlot(
|
|
|
- 1717 methCls, pn);
|
|
|
- 1718 IF vs >= 0 THEN
|
|
|
- 1719 QbeGen.VirtCallBegin(
|
|
|
- 1720 callee, vs, res)
|
|
|
- 1721 ELSE
|
|
|
- 1722 QbeGen.Mangled(pn,
|
|
|
- 1723 SymTab.ClassMethodUid(
|
|
|
- 1724 methCls, pn), mg);
|
|
|
- 1725 QbeGen.CallBegin(mg, res, 0,
|
|
|
- 1726 FALSE)
|
|
|
- 1727 END
|
|
|
- 1728 ELSIF SymTab.SymKind(pn) =
|
|
|
- 1729 SymTab.KindProc THEN
|
|
|
- 1730 res := SymTab.ProcRes(pn);
|
|
|
- 1731 QbeGen.Mangled(pn,
|
|
|
- 1732 SymTab.ProcUid(pn), mg);
|
|
|
- 1733 QbeGen.CallBegin(mg, res,
|
|
|
- 1734 SymTab.ProcDepthOf(pn),
|
|
|
- 1735 SymTab.IsExternal(pn))
|
|
|
- 1736 ELSIF (pt # SymTab.InvalidType)
|
|
|
- 1737 AND (SymTab.ClassOf(pt) = SymTab.ClProc) THEN
|
|
|
- 1738 ind := TRUE;
|
|
|
- 1739 res :=
|
|
|
- 1740 SymTab.ProcTypeRes(pt);
|
|
|
- 1741 QbeGen.CallBeginInd(callee,
|
|
|
- 1742 res, FALSE)
|
|
|
- 1743 ELSE SemError(233);
|
|
|
- 1744 ok := FALSE;
|
|
|
- 1745 res := SymTab.InvalidType
|
|
|
- 1746 END;
|
|
|
- 1747 i := 0; .)
|
|
|
- 1748 [ ActParam<pn, pt, ind, methCls, i> (. INC(i); .)
|
|
|
- 1749 { "," ActParam<pn, pt, ind, methCls, i> (. INC(i); .) } ]
|
|
|
- 1750 ")" (. IF ok THEN
|
|
|
- 1751 IF isMeth THEN
|
|
|
- 1752 np := SymTab.ClassMethodNPar(
|
|
|
- 1753 methCls, pn)
|
|
|
- 1754 ELSIF ind THEN
|
|
|
- 1755 np := SymTab.ProcTypeNPar(pt)
|
|
|
- 1756 ELSE np := SymTab.ProcNPar(pn)
|
|
|
- 1757 END;
|
|
|
- 1758 va := (NOT isMeth) AND (NOT ind)
|
|
|
- 1759 AND (SymTab.SymKind(pn) =
|
|
|
- 1760 SymTab.KindProc)
|
|
|
- 1761 AND SymTab.Varargs(pn);
|
|
|
- 1762 IF (i # np) AND NOT va THEN
|
|
|
- 1763 SemError(233); ok := FALSE
|
|
|
- 1764 END
|
|
|
- 1765 END;
|
|
|
- 1766 IF NOT ok THEN
|
|
|
- 1767 t := SymTab.InvalidType;
|
|
|
- 1768 QbeGen.CopyOp("0", q)
|
|
|
- 1769 ELSIF want THEN
|
|
|
- 1770 IF res =
|
|
|
- 1771 SymTab.InvalidType THEN
|
|
|
- 1772 SemError(233);
|
|
|
- 1773 t := SymTab.InvalidType;
|
|
|
- 1774 QbeGen.CopyOp("0", q)
|
|
|
- 1775 ELSE t := res;
|
|
|
- 1776 QbeGen.CallEnd(TRUE, q)
|
|
|
- 1777 END
|
|
|
- 1778 ELSE
|
|
|
- 1779 IF res #
|
|
|
- 1780 SymTab.InvalidType THEN
|
|
|
- 1781 SemError(233)
|
|
|
- 1782 END;
|
|
|
- 1783 t := SymTab.InvalidType;
|
|
|
- 1784 QbeGen.CopyOp("0", q);
|
|
|
- 1785 QbeGen.CallEnd(FALSE, q)
|
|
|
- 1786 END; .) .
|
|
|
- 1787 (* One actual: VAR formals take recorded designator addresses
|
|
|
- 1788 (233 otherwise); value formals take converted expressions. *)
|
|
|
- 1789 ActParam<pn: SymTab.Name; pt: SymTab.TypeIndex; ind: BOOLEAN;
|
|
|
- 1790 methCls: SymTab.TypeIndex; i: CARDINAL>
|
|
|
- 1791 (. VAR at, ft: SymTab.TypeIndex;
|
|
|
- 1792 qe, qa, qt: QbeGen.QVal;
|
|
|
- 1793 isV, conv, va: BOOLEAN;
|
|
|
- 1794 cl: CHAR;
|
|
|
- 1795 savedN, aj: CARDINAL;
|
|
|
- 1796 savedArgs: ARRAY [0 .. 31]
|
|
|
- 1797 OF AST.Node; .)
|
|
|
- 1798 = (. (* Parsing the actual can clobber
|
|
|
- 1799 the enclosing call's argument
|
|
|
- 1800 list (Factor resets astNArgs),
|
|
|
- 1801 so save/restore it. *)
|
|
|
- 1802 savedN := astNArgs; aj := 0;
|
|
|
- 1803 WHILE aj <= HIGH(astArgs) DO
|
|
|
- 1804 savedArgs[aj] := astArgs[aj];
|
|
|
- 1805 INC(aj)
|
|
|
- 1806 END; .)
|
|
|
- 1807 Expr<at, qe> (. astNArgs := savedN; aj := 0;
|
|
|
- 1808 WHILE aj <= HIGH(astArgs) DO
|
|
|
- 1809 astArgs[aj] := savedArgs[aj];
|
|
|
- 1810 INC(aj)
|
|
|
- 1811 END;
|
|
|
- 1812 IF astNArgs <= HIGH(astArgs) THEN
|
|
|
- 1813 astArgs[astNArgs] := astCur;
|
|
|
- 1814 INC(astNArgs)
|
|
|
- 1815 END;
|
|
|
- 1816 va := (NOT ind)
|
|
|
- 1817 AND (methCls =
|
|
|
- 1818 SymTab.InvalidType)
|
|
|
- 1819 AND (SymTab.SymKind(pn) =
|
|
|
- 1820 SymTab.KindProc)
|
|
|
- 1821 AND SymTab.Varargs(pn);
|
|
|
- 1822 IF ind THEN
|
|
|
- 1823 ft :=
|
|
|
- 1824 SymTab.ProcTypeParamType(pt,
|
|
|
- 1825 i);
|
|
|
- 1826 isV :=
|
|
|
- 1827 SymTab.ProcTypeParamIsVar(pt,
|
|
|
- 1828 i)
|
|
|
- 1829 ELSIF methCls #
|
|
|
- 1830 SymTab.InvalidType THEN
|
|
|
- 1831 ft :=
|
|
|
- 1832 SymTab.ClassMethodParamType(
|
|
|
- 1833 methCls, pn, i);
|
|
|
- 1834 isV :=
|
|
|
- 1835 SymTab.ClassMethodParamIsVar(
|
|
|
- 1836 methCls, pn, i)
|
|
|
- 1837 ELSE
|
|
|
- 1838 ft := SymTab.ParamType(pn, i);
|
|
|
- 1839 isV := SymTab.ParamIsVar(pn, i)
|
|
|
- 1840 END;
|
|
|
- 1841 IF (at = SymTab.InvalidType) THEN
|
|
|
- 1842 ELSIF ft = SymTab.InvalidType THEN
|
|
|
- 1843 IF va THEN
|
|
|
- 1844 QbeGen.CArgAdd(qe, at, qa, cl)
|
|
|
- 1845 END
|
|
|
- 1846 ELSIF isV THEN
|
|
|
- 1847 IF (SymTab.ClassOf(at)
|
|
|
- 1848 = SymTab.ClChar)
|
|
|
- 1849 AND (SymTab.ClassOf(ft) = SymTab.ClArray)
|
|
|
- 1850 AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
|
|
|
- 1851 = SymTab.ClChar)
|
|
|
- 1852 AND QbeGen.IsImm(qe) THEN
|
|
|
- 1853 (* 1-char string
|
|
|
- 1854 literal passed to
|
|
|
- 1855 a VAR ARRAY OF CHAR *)
|
|
|
- 1856 QbeGen.DeclCharStr(qe,
|
|
|
- 1857 qa);
|
|
|
- 1858 IF NOT QbeGen.CallArg(qa,
|
|
|
- 1859 "l") THEN
|
|
|
- 1860 SemError(233)
|
|
|
- 1861 END
|
|
|
- 1862 ELSIF NOT QbeGen.AddrOfVal(qe,
|
|
|
- 1863 qa) THEN
|
|
|
- 1864 SemError(233)
|
|
|
- 1865 ELSIF NOT SymTab.VarParamOk(at,
|
|
|
- 1866 ft) THEN
|
|
|
- 1867 SemError(233)
|
|
|
- 1868 ELSIF NOT QbeGen.CallArg(qa,
|
|
|
- 1869 "l") THEN
|
|
|
- 1870 SemError(233)
|
|
|
- 1871 END
|
|
|
- 1872 ELSE
|
|
|
- 1873 IF (SymTab.ClassOf(at)
|
|
|
- 1874 = SymTab.ClChar)
|
|
|
- 1875 AND (SymTab.ClassOf(ft) = SymTab.ClArray)
|
|
|
- 1876 AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
|
|
|
- 1877 = SymTab.ClChar)
|
|
|
- 1878 AND QbeGen.IsImm(qe) THEN
|
|
|
- 1879 (* 1-char string
|
|
|
- 1880 literal passed to
|
|
|
- 1881 ARRAY OF CHAR *)
|
|
|
- 1882 QbeGen.DeclCharStr(qe,
|
|
|
- 1883 qa);
|
|
|
- 1884 IF NOT QbeGen.CallArg(qa,
|
|
|
- 1885 "l") THEN
|
|
|
- 1886 SemError(233)
|
|
|
- 1887 END
|
|
|
- 1888 ELSIF NOT SymTab.Assignable(at,
|
|
|
- 1889 ft) THEN
|
|
|
- 1890 SemError(233)
|
|
|
- 1891 ELSE
|
|
|
- 1892 conv := (SymTab.ClassOf(
|
|
|
- 1893 ft) = SymTab.ClReal)
|
|
|
- 1894 AND SymTab.IsIntFamily(at);
|
|
|
- 1895 IF conv THEN
|
|
|
- 1896 QbeGen.ConvIR(qe, qt);
|
|
|
- 1897 IF NOT QbeGen.CallArg(qt,
|
|
|
- 1898 "d") THEN
|
|
|
- 1899 SemError(233)
|
|
|
- 1900 END
|
|
|
- 1901 ELSIF NOT QbeGen.CallArg(qe,
|
|
|
- 1902 QbeGen.ArgClass(ft)) THEN
|
|
|
- 1903 SemError(233)
|
|
|
- 1904 END
|
|
|
- 1905 END
|
|
|
- 1906 END; .) .
|
|
|
- 1907 IfStat (. VAR t: SymTab.TypeIndex;
|
|
|
- 1908 q, lThen, lElse, lEnd:
|
|
|
- 1909 QbeGen.QVal;
|
|
|
- 1910 hasElse: BOOLEAN;
|
|
|
- 1911 astCond, astIf, astLast,
|
|
|
- 1912 astNode: AST.Node; .)
|
|
|
- 1913 = "IF" (. hasElse := FALSE; .)
|
|
|
- 1914 Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
|
|
|
- 1915 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
- 1916 SemError(214) END;
|
|
|
- 1917 QbeGen.NewLabel(lThen);
|
|
|
- 1918 QbeGen.NewLabel(lElse);
|
|
|
- 1919 QbeGen.NewLabel(lEnd);
|
|
|
- 1920 QbeGen.Jnz(q, lThen, lElse);
|
|
|
- 1921 QbeGen.EmitLabel(lThen); .)
|
|
|
- 1922 "THEN" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkIf);
|
|
|
- 1923 AST.SetChild(astNode, 0, astCond);
|
|
|
- 1924 AST.SetChild(astNode, 1, astStmt);
|
|
|
- 1925 astIf := astNode;
|
|
|
- 1926 astLast := astNode;
|
|
|
- 1927 QbeGen.Jmp(lEnd); .)
|
|
|
- 1928 { "ELSIF" (. QbeGen.EmitLabel(lElse);
|
|
|
- 1929 QbeGen.NewLabel(lElse); .)
|
|
|
- 1930 Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
|
|
|
- 1931 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
- 1932 SemError(214) END;
|
|
|
- 1933 QbeGen.NewLabel(lThen);
|
|
|
- 1934 QbeGen.Jnz(q, lThen, lElse);
|
|
|
- 1935 QbeGen.EmitLabel(lThen); .)
|
|
|
- 1936 "THEN" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkIf);
|
|
|
- 1937 AST.SetChild(astNode, 0, astCond);
|
|
|
- 1938 AST.SetChild(astNode, 1, astStmt);
|
|
|
- 1939 AST.SetChild(astLast, 2, astNode);
|
|
|
- 1940 astLast := astNode;
|
|
|
- 1941 QbeGen.Jmp(lEnd); .) }
|
|
|
- 1942 [ "ELSE" (. QbeGen.EmitLabel(lElse);
|
|
|
- 1943 hasElse := TRUE;
|
|
|
- 1944 astStmt := AST.NoNode; .)
|
|
|
- 1945 [ StatSeq ] (. AST.SetChild(astLast, 2, astStmt); .) ]
|
|
|
- 1946 "END" (. astStmt := astIf;
|
|
|
- 1947 IF hasElse THEN
|
|
|
- 1948 QbeGen.EmitLabel(lEnd)
|
|
|
- 1949 ELSE QbeGen.EmitLabel(lElse);
|
|
|
- 1950 QbeGen.EmitLabel(lEnd)
|
|
|
- 1951 END; .) .
|
|
|
- 1952 WhileStat (. VAR t: SymTab.TypeIndex;
|
|
|
- 1953 q, lTop, lBody, lEnd:
|
|
|
- 1954 QbeGen.QVal;
|
|
|
- 1955 astCond, astNode: AST.Node; .)
|
|
|
- 1956 = "WHILE" (. astStmt := AST.NoNode;
|
|
|
- 1957 QbeGen.NewLabel(lTop);
|
|
|
- 1958 QbeGen.NewLabel(lBody);
|
|
|
- 1959 QbeGen.NewLabel(lEnd);
|
|
|
- 1960 QbeGen.EmitLabel(lTop); .)
|
|
|
- 1961 Expr<t, q> (. astCond := astCur;
|
|
|
- 1962 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
- 1963 SemError(214) END;
|
|
|
- 1964 QbeGen.Jnz(q, lBody, lEnd);
|
|
|
- 1965 QbeGen.EmitLabel(lBody); .)
|
|
|
- 1966 "DO" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkWhile);
|
|
|
- 1967 AST.SetChild(astNode, 0, astCond);
|
|
|
- 1968 AST.SetChild(astNode, 1, astStmt);
|
|
|
- 1969 astStmt := astNode;
|
|
|
- 1970 QbeGen.Jmp(lTop); .)
|
|
|
- 1971 "END" (. QbeGen.EmitLabel(lEnd); .) .
|
|
|
- 1972 RepeatStat (. VAR t: SymTab.TypeIndex;
|
|
|
- 1973 q, lTop, lEnd: QbeGen.QVal;
|
|
|
- 1974 astCond, astBody, astNode:
|
|
|
- 1975 AST.Node; .)
|
|
|
- 1976 = "REPEAT" (. astStmt := AST.NoNode;
|
|
|
- 1977 QbeGen.NewLabel(lTop);
|
|
|
- 1978 QbeGen.NewLabel(lEnd);
|
|
|
- 1979 QbeGen.EmitLabel(lTop); .)
|
|
|
- 1980 [ StatSeq ] (. astBody := astStmt; .)
|
|
|
- 1981 "UNTIL" Expr<t, q> (. astCond := astCur;
|
|
|
- 1982 astNode := AST.MakeNode(AST.NkRepeat);
|
|
|
- 1983 AST.SetChild(astNode, 0, astBody);
|
|
|
- 1984 AST.SetChild(astNode, 1, astCond);
|
|
|
- 1985 astStmt := astNode;
|
|
|
- 1986 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
- 1987 SemError(214) END;
|
|
|
- 1988 QbeGen.Jnz(q, lEnd, lTop);
|
|
|
- 1989 QbeGen.EmitLabel(lEnd); .) .
|
|
|
- 1990 LoopStat (. VAR lTop, lEnd: QbeGen.QVal; astNode: AST.Node; .)
|
|
|
- 1991 = "LOOP" (. QbeGen.NewLabel(lTop);
|
|
|
- 1992 astStmt := AST.NoNode;
|
|
|
- 1993 QbeGen.NewLabel(lEnd);
|
|
|
- 1994 QbeGen.PushLoop(lEnd);
|
|
|
- 1995 QbeGen.EmitLabel(lTop); .)
|
|
|
- 1996 [ StatSeq ]
|
|
|
- 1997 "END" (. astNode := AST.MakeNode(AST.NkLoop);
|
|
|
- 1998 AST.SetChild(astNode, 0, astStmt);
|
|
|
- 1999 astStmt := astNode;
|
|
|
- 2000 QbeGen.Jmp(lTop);
|
|
|
- 2001 QbeGen.PopLoop;
|
|
|
- 2002 QbeGen.EmitLabel(lEnd); .) .
|
|
|
- 2003 (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
|
|
|
- 2004 Runtime direction would need a compare-select; the literal
|
|
|
- 2005 sign picks cslew/csegew at "DO" time. *)
|
|
|
- 2006 ForStat (. VAR lv: SymTab.Name;
|
|
|
- 2007 tlo, thi, tby:
|
|
|
- 2008 SymTab.TypeIndex;
|
|
|
- 2009 qlo, qhi, qby, qt, qk, qb:
|
|
|
- 2010 QbeGen.QVal;
|
|
|
- 2011 lTop, lBody, lEnd:
|
|
|
- 2012 QbeGen.QVal;
|
|
|
- 2013 by: INTEGER;
|
|
|
- 2014 ok: BOOLEAN;
|
|
|
- 2015 astVar, astLo, astHi, astBy,
|
|
|
- 2016 astNode: AST.Node; .)
|
|
|
- 2017 = "FOR" (. by := 1; .)
|
|
|
- 2018 GetIdent<lv> (. astVar := AST.MakeLeaf(AST.NkIdent, lv);
|
|
|
- 2019 astStmt := AST.NoNode;
|
|
|
- 2020 astBy := AST.NoNode;
|
|
|
- 2021 ok := SymTab.Lookup(lv);
|
|
|
- 2022 IF NOT ok THEN
|
|
|
- 2023 SemError(201)
|
|
|
- 2024 ELSIF (SymTab.SymKind(lv) #
|
|
|
- 2025 SymTab.KindVar)
|
|
|
- 2026 AND (SymTab.SymKind(lv) #
|
|
|
- 2027 SymTab.KindParam) THEN
|
|
|
- 2028 SemError(220); ok := FALSE
|
|
|
- 2029 ELSIF NOT SymTab.IsIntFamily(
|
|
|
- 2030 SymTab.SymType(lv)) THEN
|
|
|
- 2031 SemError(220); ok := FALSE
|
|
|
- 2032 END; .)
|
|
|
- 2033 ":=" Expr<tlo, qlo> (. astLo := astCur;
|
|
|
- 2034 IF NOT SymTab.IsIntFamily(tlo) THEN
|
|
|
- 2035 SemError(220); ok := FALSE
|
|
|
- 2036 END; .)
|
|
|
- 2037 "TO" Expr<thi, qhi> (. astHi := astCur;
|
|
|
- 2038 IF NOT SymTab.IsIntFamily(thi) THEN
|
|
|
- 2039 SemError(220); ok := FALSE
|
|
|
- 2040 END; .)
|
|
|
- 2041 [ "BY" Expr<tby, qby> (. astBy := astCur;
|
|
|
- 2042 IF (tby #
|
|
|
- 2043 SymTab.InvalidType)
|
|
|
- 2044 AND NOT SymTab.IsIntFamily(tby) THEN
|
|
|
- 2045 SemError(220); ok := FALSE
|
|
|
- 2046 END;
|
|
|
- 2047 IF NOT SymTab.ConstInt(qby, by) THEN
|
|
|
- 2048 SemError(230); by := 1
|
|
|
- 2049 ELSIF by = 0 THEN
|
|
|
- 2050 SemError(220); by := 1
|
|
|
- 2051 END; .) ]
|
|
|
- 2052 "DO" (. IF ok THEN
|
|
|
- 2053 QbeGen.StoreVar(lv, qlo,
|
|
|
- 2054 FALSE) END;
|
|
|
- 2055 QbeGen.NewLabel(lTop);
|
|
|
- 2056 QbeGen.NewLabel(lBody);
|
|
|
- 2057 QbeGen.NewLabel(lEnd);
|
|
|
- 2058 QbeGen.EmitLabel(lTop);
|
|
|
- 2059 QbeGen.LoadVar(lv, FALSE, qt);
|
|
|
- 2060 QbeGen.NewTemp(qk);
|
|
|
- 2061 IF by > 0 THEN
|
|
|
- 2062 QbeGen.Op3("cslew", qk,
|
|
|
- 2063 qt, qhi, FALSE)
|
|
|
- 2064 ELSE QbeGen.Op3("csgew", qk,
|
|
|
- 2065 qt, qhi, FALSE)
|
|
|
- 2066 END;
|
|
|
- 2067 QbeGen.Jnz(qk, lBody, lEnd);
|
|
|
- 2068 QbeGen.EmitLabel(lBody); .)
|
|
|
- 2069 [ StatSeq ]
|
|
|
- 2070 "END" (. astNode := AST.MakeNode(AST.NkFor);
|
|
|
- 2071 AST.SetChild(astNode, 0, astVar);
|
|
|
- 2072 AST.SetChild(astNode, 1, astLo);
|
|
|
- 2073 AST.SetChild(astNode, 2, astHi);
|
|
|
- 2074 AST.SetChild(astNode, 3, astBy);
|
|
|
- 2075 AST.SetChild(astNode, 4, astStmt);
|
|
|
- 2076 astStmt := astNode;
|
|
|
- 2077 IF ok THEN
|
|
|
- 2078 QbeGen.LoadVar(lv, FALSE,
|
|
|
- 2079 qt);
|
|
|
- 2080 QbeGen.IntStr(by, qb);
|
|
|
- 2081 QbeGen.NewTemp(qk);
|
|
|
- 2082 QbeGen.Op3("add", qk,
|
|
|
- 2083 qt, qb, FALSE);
|
|
|
- 2084 QbeGen.StoreVar(lv, qk,
|
|
|
- 2085 FALSE) END;
|
|
|
- 2086 QbeGen.Jmp(lTop);
|
|
|
- 2087 QbeGen.EmitLabel(lEnd); .) .
|
|
|
- 2088 CaseStat (. VAR tsel: SymTab.TypeIndex;
|
|
|
- 2089 qsel, lEnd: QbeGen.QVal;
|
|
|
- 2090 arm, astNode, astArms,
|
|
|
- 2091 astArmsTail: AST.Node; .)
|
|
|
- 2092 = "CASE" Expr<tsel, qsel> (. astNode := AST.MakeNode(AST.NkCase);
|
|
|
- 2093 AST.SetChild(astNode, 0, astCur);
|
|
|
- 2094 astArms := AST.NoNode;
|
|
|
- 2095 astArmsTail := AST.NoNode;
|
|
|
- 2096 QbeGen.NewLabel(lEnd); .)
|
|
|
- 2097 "OF" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail>
|
|
|
- 2098 { "|" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail> }
|
|
|
- 2099 [ "ELSE" (. astStmt := AST.NoNode; .)
|
|
|
- 2100 [ StatSeq ] (. arm := AST.MakeNode(AST.NkCaseArm);
|
|
|
- 2101 AST.SetOp(arm, 1);
|
|
|
- 2102 AST.SetChild(arm, 0, astStmt);
|
|
|
- 2103 AstAppend(AST.NkBlock,
|
|
|
- 2104 astArms, astArmsTail, arm); .) ]
|
|
|
- 2105 "END" (. AST.SetChild(astNode, 1, astArms);
|
|
|
- 2106 astStmt := astNode;
|
|
|
- 2107 QbeGen.EmitLabel(lEnd); .) .
|
|
|
- 2108 (* Compare-chain lowering: each alternative ends its match-tests
|
|
|
- 2109 with "jmp lAfter", so the no-match fallthrough skips the body:
|
|
|
- 2110 "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
|
|
|
- 2111 lAfter:". Falls into the next alternative, ELSE, or END. *)
|
|
|
- 2112 CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
|
|
|
- 2113 lEnd: QbeGen.QVal; VAR arms, armsTail: AST.Node>
|
|
|
- 2114 (. VAR lBody, lAfter: QbeGen.QVal;
|
|
|
- 2115 arm: AST.Node; .)
|
|
|
- 2116 = (. arm := AST.MakeNode(AST.NkCaseArm);
|
|
|
- 2117 QbeGen.NewLabel(lBody);
|
|
|
- 2118 QbeGen.NewLabel(lAfter); .)
|
|
|
- 2119 CaseLabel<tsel, qsel, lBody, arm>
|
|
|
- 2120 { "," CaseLabel<tsel, qsel, lBody, arm> }
|
|
|
- 2121 ":" (. astStmt := AST.NoNode;
|
|
|
- 2122 QbeGen.Jmp(lAfter);
|
|
|
- 2123 QbeGen.EmitLabel(lBody); .)
|
|
|
- 2124 [ StatSeq ] (. AST.SetChild(arm, AST.NChild(arm),
|
|
|
- 2125 astStmt);
|
|
|
- 2126 AstAppend(AST.NkBlock,
|
|
|
- 2127 arms, armsTail, arm);
|
|
|
- 2128 QbeGen.Jmp(lEnd);
|
|
|
- 2129 QbeGen.EmitLabel(lAfter); .) .
|
|
|
- 2130 CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
|
|
|
- 2131 lBody: QbeGen.QVal; arm: AST.Node>
|
|
|
- 2132 (. VAR t2, t3: SymTab.TypeIndex;
|
|
|
- 2133 q2, q3, qc, qd, qe:
|
|
|
- 2134 QbeGen.QVal;
|
|
|
- 2135 astLab: AST.Node;
|
|
|
- 2136 lNext: QbeGen.QVal; .)
|
|
|
- 2137 = Expr<t2, q2> (. astLab := astCur;
|
|
|
- 2138 IF (t2 #
|
|
|
- 2139 SymTab.InvalidType)
|
|
|
- 2140 AND (tsel #
|
|
|
- 2141 SymTab.InvalidType)
|
|
|
- 2142 AND ((SymTab.ClassOf(t2) =
|
|
|
- 2143 SymTab.ClSet)
|
|
|
- 2144 OR (SymTab.ClassOf(tsel) =
|
|
|
- 2145 SymTab.ClSet)) THEN
|
|
|
- 2146 SemError(230)
|
|
|
- 2147 ELSIF (t2 #
|
|
|
- 2148 SymTab.InvalidType)
|
|
|
- 2149 AND (tsel #
|
|
|
- 2150 SymTab.InvalidType)
|
|
|
- 2151 AND NOT SymTab.EqCheck(t2,
|
|
|
- 2152 tsel) THEN
|
|
|
- 2153 SemError(213) END;
|
|
|
- 2154 IF NOT QbeGen.IsImm(q2) THEN
|
|
|
- 2155 SemError(230);
|
|
|
- 2156 QbeGen.CopyOp("0", q2)
|
|
|
- 2157 END;
|
|
|
- 2158 QbeGen.NewLabel(lNext);
|
|
|
- 2159 QbeGen.Cmp(SymTab.OpEq,
|
|
|
- 2160 qsel, q2, qc, FALSE);
|
|
|
- 2161 QbeGen.Jnz(qc, lBody, lNext);
|
|
|
- 2162 QbeGen.EmitLabel(lNext); .)
|
|
|
- 2163 [ ".." Expr<t3, q3> (. astLab := AST.MakeBin(
|
|
|
- 2164 AST.NkSubrange, 0, astLab, astCur);
|
|
|
- 2165 IF (t3 #
|
|
|
- 2166 SymTab.InvalidType)
|
|
|
- 2167 AND (tsel #
|
|
|
- 2168 SymTab.InvalidType)
|
|
|
- 2169 AND NOT SymTab.EqCheck(t3,
|
|
|
- 2170 tsel) THEN
|
|
|
- 2171 SemError(213) END;
|
|
|
- 2172 IF NOT QbeGen.IsImm(q3) THEN
|
|
|
- 2173 SemError(230);
|
|
|
- 2174 QbeGen.CopyOp("0", q3)
|
|
|
- 2175 END;
|
|
|
- 2176 QbeGen.Cmp(SymTab.OpGe,
|
|
|
- 2177 qsel, q2, qc, FALSE);
|
|
|
- 2178 QbeGen.Cmp(SymTab.OpLe,
|
|
|
- 2179 qsel, q3, qd, FALSE);
|
|
|
- 2180 QbeGen.NewTemp(qe);
|
|
|
- 2181 QbeGen.Op3("and", qe, qc, qd,
|
|
|
- 2182 FALSE);
|
|
|
- 2183 QbeGen.NewLabel(lNext);
|
|
|
- 2184 QbeGen.Jnz(qe, lBody, lNext);
|
|
|
- 2185 QbeGen.EmitLabel(lNext); .) ]
|
|
|
- 2186 (. AST.SetChild(arm,
|
|
|
- 2187 AST.NChild(arm), astLab); .) .
|
|
|
- 2188 ReturnStat (. VAR t: SymTab.TypeIndex;
|
|
|
- 2189 q, qt: QbeGen.QVal;
|
|
|
- 2190 res: SymTab.TypeIndex;
|
|
|
- 2191 hadE, conv: BOOLEAN;
|
|
|
- 2192 astVal, astNode: AST.Node; .)
|
|
|
- 2193 = "RETURN" (. hadE := FALSE; astStmt := AST.NoNode; .)
|
|
|
- 2194 [ Expr<t, q> (. hadE := TRUE; astVal := astCur; .) ]
|
|
|
- 2195 (. astNode := AST.MakeNode(AST.NkReturn);
|
|
|
- 2196 IF hadE THEN
|
|
|
- 2197 AST.SetChild(astNode, 0, astVal)
|
|
|
- 2198 END;
|
|
|
- 2199 astStmt := astNode;
|
|
|
- 2200 conv := FALSE;
|
|
|
- 2201 IF NOT SymTab.InProc() THEN
|
|
|
- 2202 SemError(232)
|
|
|
- 2203 ELSE res := SymTab.CurRes();
|
|
|
- 2204 IF NOT hadE THEN
|
|
|
- 2205 IF res #
|
|
|
- 2206 SymTab.InvalidType THEN
|
|
|
- 2207 SemError(232)
|
|
|
- 2208 ELSE QbeGen.EmitRet(q,
|
|
|
- 2209 FALSE)
|
|
|
- 2210 END
|
|
|
- 2211 ELSIF (res =
|
|
|
- 2212 SymTab.InvalidType)
|
|
|
- 2213 OR (t #
|
|
|
- 2214 SymTab.InvalidType)
|
|
|
- 2215 AND NOT SymTab.Assignable(t,
|
|
|
- 2216 res) THEN
|
|
|
- 2217 SemError(232)
|
|
|
- 2218 ELSE
|
|
|
- 2219 conv := (SymTab.ClassOf(
|
|
|
- 2220 res) = SymTab.ClReal)
|
|
|
- 2221 AND SymTab.IsIntFamily(t);
|
|
|
- 2222 IF conv THEN
|
|
|
- 2223 QbeGen.ConvIR(q, qt);
|
|
|
- 2224 QbeGen.EmitRet(qt, TRUE)
|
|
|
- 2225 ELSE QbeGen.EmitRet(q, TRUE)
|
|
|
- 2226 END
|
|
|
- 2227 END
|
|
|
- 2228 END; .) .
|
|
|
- 2229 HaltStat (. VAR t: SymTab.TypeIndex;
|
|
|
- 2230 q: QbeGen.QVal;
|
|
|
- 2231 astVal, astNode: AST.Node; .)
|
|
|
- 2232 = "HALT" (. astVal := AST.NoNode; .)
|
|
|
- 2233 [ "(" Expr<t, q> (. astVal := astCur; .) ")" ]
|
|
|
- 2234 (. astNode := AST.MakeNode(AST.NkHalt);
|
|
|
- 2235 IF astVal # AST.NoNode THEN
|
|
|
- 2236 AST.SetChild(astNode, 0, astVal)
|
|
|
- 2237 END;
|
|
|
- 2238 astStmt := astNode;
|
|
|
- 2239 QbeGen.HaltQ; .) .
|
|
|
- 2240 (* Designator: scalar loads, array addresses, and index suffixes.
|
|
|
- 2241 Each index descends one level (bounds-checked, trap on breach);
|
|
|
- 2242 nested levels reload the inner descriptor address. q ends as the
|
|
|
- 2243 value (scalars), the descriptor address (plain arrays), or the
|
|
|
- 2244 element address (indexed); sfx marks the indexed form. *)
|
|
|
- 2245 Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
|
|
|
- 2246 VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
|
|
|
- 2247 (. VAR n, fn, mal: SymTab.Name;
|
|
|
- 2248 cls: INTEGER;
|
|
|
- 2249 ic: SymTab.TypeIndex;
|
|
|
- 2250 curT, it, eT, bt:
|
|
|
- 2251 SymTab.TypeIndex;
|
|
|
- 2252 iq, ql, qlo, qhi, qe:
|
|
|
- 2253 QbeGen.QVal;
|
|
|
- 2254 lo, hi: INTEGER;
|
|
|
- 2255 fo: INTEGER;
|
|
|
- 2256 isOpen: BOOLEAN;
|
|
|
- 2257 qb, cv: QbeGen.QVal;
|
|
|
- 2258 fid, fref, slot: INTEGER;
|
|
|
- 2259 r: BOOLEAN;
|
|
|
- 2260 astDes, astSel: AST.Node; .)
|
|
|
- 2261 = GetIdent<n> (. methCls := SymTab.InvalidType;
|
|
|
- 2262 QbeGen.CopyOp(n, qn);
|
|
|
- 2263 sfx := FALSE;
|
|
|
- 2264 fid := 0; fref := 0; slot := 0;
|
|
|
- 2265 IF NOT SymTab.Lookup(n) THEN
|
|
|
- 2266 (* a bare method name inside
|
|
|
- 2267 a CLASS IMPLEMENTATION
|
|
|
- 2268 is a sibling call on
|
|
|
- 2269 THIS *)
|
|
|
- 2270 ic := SymTab.CurImplClass();
|
|
|
- 2271 IF (ic #
|
|
|
- 2272 SymTab.InvalidType)
|
|
|
- 2273 AND SymTab.MethodExists(ic, n) THEN
|
|
|
- 2274 sfx := FALSE;
|
|
|
- 2275 QbeGen.ThisBase(q);
|
|
|
- 2276 QbeGen.ArmRecv(q);
|
|
|
- 2277 methCls := ic;
|
|
|
- 2278 k := SymTab.KindProc;
|
|
|
- 2279 t := SymTab.InvalidType
|
|
|
- 2280 ELSIF SymTab.InProc() THEN
|
|
|
- 2281 (* not declared yet: a
|
|
|
- 2282 forward reference to a
|
|
|
- 2283 module-level variable
|
|
|
- 2284 declared further down. *)
|
|
|
- 2285 k := SymTab.KindVar;
|
|
|
- 2286 r := SymTab.FwdVarRef(n, k,
|
|
|
- 2287 fref, t);
|
|
|
- 2288 slot := QbeGen.FwdDesignator();
|
|
|
- 2289 FwdVarNote(fref, slot);
|
|
|
- 2290 fid := slot;
|
|
|
- 2291 QbeGen.FwdAddrOper(fid, q);
|
|
|
- 2292 sfx := TRUE
|
|
|
- 2293 ELSE
|
|
|
- 2294 SemError(201);
|
|
|
- 2295 t :=
|
|
|
- 2296 SymTab.InvalidType;
|
|
|
- 2297 k := -1;
|
|
|
- 2298 QbeGen.CopyOp("0", q)
|
|
|
- 2299 END
|
|
|
- 2300 ELSE
|
|
|
- 2301 t := SymTab.SymType(n);
|
|
|
- 2302 k := SymTab.SymKind(n);
|
|
|
- 2303 IF k = SymTab.KindConst THEN
|
|
|
- 2304 IF SymTab.Equal(n,
|
|
|
- 2305 "TRUE") THEN
|
|
|
- 2306 t := SymTab.BoolType();
|
|
|
- 2307 QbeGen.CopyOp("1", q)
|
|
|
- 2308 ELSIF SymTab.Equal(n,
|
|
|
- 2309 "FALSE") THEN
|
|
|
- 2310 t := SymTab.BoolType();
|
|
|
- 2311 QbeGen.CopyOp("0", q)
|
|
|
- 2312 ELSIF SymTab.Equal(n,
|
|
|
- 2313 "NIL") THEN
|
|
|
- 2314 QbeGen.CopyOp("0", q)
|
|
|
- 2315 ELSE
|
|
|
- 2316 cls :=
|
|
|
- 2317 SymTab.ClassOf(t);
|
|
|
- 2318 IF (t #
|
|
|
- 2319 SymTab.InvalidType)
|
|
|
- 2320 AND ((cls = SymTab.ClInt)
|
|
|
- 2321 OR (cls
|
|
|
- 2322 = SymTab.ClChar)
|
|
|
- 2323 OR (cls
|
|
|
- 2324 = SymTab.ClEnum)
|
|
|
- 2325 OR (cls
|
|
|
- 2326 = SymTab.ClReal)
|
|
|
- 2327 OR (cls
|
|
|
- 2328 = SymTab.ClLong)
|
|
|
- 2329 OR (cls
|
|
|
- 2330 = SymTab.ClNil)) THEN
|
|
|
- 2331 IF cls = SymTab.ClNil THEN
|
|
|
- 2332 QbeGen.CopyOp("0", q)
|
|
|
- 2333 ELSIF ((cls
|
|
|
- 2334 = SymTab.ClInt)
|
|
|
- 2335 OR (cls
|
|
|
- 2336 = SymTab.ClChar)
|
|
|
- 2337 OR (cls
|
|
|
- 2338 = SymTab.ClEnum)
|
|
|
- 2339 OR (cls
|
|
|
- 2340 = SymTab.ClLong))
|
|
|
- 2341 AND SymTab.GetSymVal(n, cv)
|
|
|
- 2342 AND QbeGen.IsImm(cv) THEN
|
|
|
- 2343 QbeGen.CopyOp(cv, q)
|
|
|
- 2344 ELSE
|
|
|
- 2345 QbeGen.LoadVar(n,
|
|
|
- 2346 cls = SymTab.ClReal,
|
|
|
- 2347 q)
|
|
|
- 2348 END
|
|
|
- 2349 ELSIF (cls = SymTab.ClArray)
|
|
|
- 2350 OR (cls = SymTab.ClRecord)
|
|
|
- 2351 OR (cls = SymTab.ClClass)
|
|
|
- 2352 OR (cls = SymTab.ClStr)
|
|
|
- 2353 OR (cls = SymTab.ClUStr) THEN
|
|
|
- 2354 (* aggregate constant:
|
|
|
- 2355 its value IS the
|
|
|
- 2356 descriptor address *)
|
|
|
- 2357 IF SymTab.GetSymVal(n, cv) THEN
|
|
|
- 2358 QbeGen.CopyOp(cv, q)
|
|
|
- 2359 ELSE
|
|
|
- 2360 QbeGen.CopyOp("0", q)
|
|
|
- 2361 END
|
|
|
- 2362 ELSE
|
|
|
- 2363 IF t #
|
|
|
- 2364 SymTab.InvalidType THEN
|
|
|
- 2365 SemError(230)
|
|
|
- 2366 END;
|
|
|
- 2367 QbeGen.CopyOp("0", q)
|
|
|
- 2368 END
|
|
|
- 2369 END
|
|
|
- 2370 ELSIF (k = SymTab.KindVar)
|
|
|
- 2371 OR (k = SymTab.KindParam) THEN
|
|
|
- 2372 cls :=
|
|
|
- 2373 SymTab.ClassOf(t);
|
|
|
- 2374 IF (cls = SymTab.ClInt)
|
|
|
- 2375 OR (cls = SymTab.ClBool)
|
|
|
- 2376 OR (cls = SymTab.ClChar)
|
|
|
- 2377 OR (cls = SymTab.ClUChar)
|
|
|
- 2378 OR (cls = SymTab.ClEnum)
|
|
|
- 2379 OR (cls
|
|
|
- 2380 = SymTab.ClReal) THEN
|
|
|
- 2381 QbeGen.LoadVar(n,
|
|
|
- 2382 cls = SymTab.ClReal, q)
|
|
|
- 2383 ELSIF (cls = SymTab.ClPtr)
|
|
|
- 2384 OR (cls = SymTab.ClProc) THEN
|
|
|
- 2385 QbeGen.LoadPtr(n, q)
|
|
|
- 2386 ELSIF cls = SymTab.ClLong THEN
|
|
|
- 2387 QbeGen.LoadLong(n, q)
|
|
|
- 2388 ELSIF (cls
|
|
|
- 2389 = SymTab.ClArray)
|
|
|
- 2390 OR (cls
|
|
|
- 2391 = SymTab.ClSet)
|
|
|
- 2392 OR (cls
|
|
|
- 2393 = SymTab.ClRecord)
|
|
|
- 2394 OR (cls
|
|
|
- 2395 = SymTab.ClUStr)
|
|
|
- 2396 OR (cls
|
|
|
- 2397 = SymTab.ClClass) THEN
|
|
|
- 2398 QbeGen.AddrOf(n, q)
|
|
|
- 2399 ELSE SemError(230);
|
|
|
- 2400 QbeGen.CopyOp("0", q)
|
|
|
- 2401 END
|
|
|
- 2402 ELSE QbeGen.CopyOp("0", q);
|
|
|
- 2403 IF k = SymTab.KindImport THEN
|
|
|
- 2404 SemError(230)
|
|
|
- 2405 ELSIF k =
|
|
|
- 2406 SymTab.KindProc THEN
|
|
|
- 2407 (* bare procedure name:
|
|
|
- 2408 a following ArgList
|
|
|
- 2409 makes it a call;
|
|
|
- 2410 otherwise Fact
|
|
|
- 2411 reports 230 *)
|
|
|
- 2412 ELSE
|
|
|
- 2413 IF k = SymTab.KindField THEN
|
|
|
- 2414 IF QbeGen.TopWith(qb) THEN
|
|
|
- 2415 fo :=
|
|
|
- 2416 SymTab.FieldOffset(
|
|
|
- 2417 SymTab.FieldOwner(n),
|
|
|
- 2418 n);
|
|
|
- 2419 QbeGen.FieldAddr(qb,
|
|
|
- 2420 fo, q);
|
|
|
- 2421 sfx := TRUE
|
|
|
- 2422 ELSE SemError(230);
|
|
|
- 2423 QbeGen.CopyOp("0", q)
|
|
|
- 2424 END
|
|
|
- 2425 END
|
|
|
- 2426 END
|
|
|
- 2427 END
|
|
|
- 2428 END; .)
|
|
|
- 2429 (. astDes := AST.MakeNode(AST.NkDesignator);
|
|
|
- 2430 AST.SetChild(astDes, AST.NChild(astDes), AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
- 2431 { "[" Expr<it, iq>
|
|
|
- 2432 (. AST.SetChild(astDes, AST.NChild(astDes),
|
|
|
- 2433 AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
- 2434 ELSIF SymTab.ClassOf(t) #
|
|
|
- 2435 SymTab.ClArray THEN
|
|
|
- 2436 SemError(217);
|
|
|
- 2437 t := SymTab.InvalidType
|
|
|
- 2438 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
- 2439 AND (SymTab.ClassOf(it) #
|
|
|
- 2440 SymTab.ClChar)
|
|
|
- 2441 AND (SymTab.ClassOf(it) #
|
|
|
- 2442 SymTab.ClEnum) THEN
|
|
|
- 2443 SemError(218);
|
|
|
- 2444 t := SymTab.InvalidType
|
|
|
- 2445 ELSE
|
|
|
- 2446 QbeGen.WidenIndex(iq, ql);
|
|
|
- 2447 isOpen :=
|
|
|
- 2448 SymTab.IsOpenArray(t);
|
|
|
- 2449 IF isOpen THEN
|
|
|
- 2450 QbeGen.CopyOp("0", qlo);
|
|
|
- 2451 IF SymTab.IsCharArray(t)
|
|
|
- 2452 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2453 QbeGen.OpenHiChar(q, qhi)
|
|
|
- 2454 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
- 2455 END
|
|
|
- 2456 ELSE
|
|
|
- 2457 lo := SymTab.ArrayLo(t);
|
|
|
- 2458 hi := SymTab.ArrayHi(t);
|
|
|
- 2459 IF SymTab.IsCharArray(t)
|
|
|
- 2460 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2461 hi := hi + 1
|
|
|
- 2462 END;
|
|
|
- 2463 QbeGen.IntStr(lo, qlo);
|
|
|
- 2464 QbeGen.IntStr(hi, qhi)
|
|
|
- 2465 END;
|
|
|
- 2466 QbeGen.CheckRange(ql, qlo,
|
|
|
- 2467 qhi);
|
|
|
- 2468 eT := SymTab.ArrayElem(t);
|
|
|
- 2469 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
- 2470 t, qe);
|
|
|
- 2471 IF SymTab.ClassOf(eT) =
|
|
|
- 2472 SymTab.ClArray THEN
|
|
|
- 2473 QbeGen.ElemLoad(qe, eT, q)
|
|
|
- 2474 ELSE QbeGen.CopyOp(qe, q)
|
|
|
- 2475 END;
|
|
|
- 2476 t := eT; sfx := TRUE
|
|
|
- 2477 END; .)
|
|
|
- 2478 { "," Expr<it, iq>
|
|
|
- 2479 (. AST.SetChild(astDes, AST.NChild(astDes),
|
|
|
- 2480 AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
- 2481 ELSIF SymTab.ClassOf(t) #
|
|
|
- 2482 SymTab.ClArray THEN
|
|
|
- 2483 SemError(217);
|
|
|
- 2484 t := SymTab.InvalidType
|
|
|
- 2485 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
- 2486 AND (SymTab.ClassOf(it) #
|
|
|
- 2487 SymTab.ClChar)
|
|
|
- 2488 AND (SymTab.ClassOf(it) #
|
|
|
- 2489 SymTab.ClEnum) THEN
|
|
|
- 2490 SemError(218);
|
|
|
- 2491 t := SymTab.InvalidType
|
|
|
- 2492 ELSE
|
|
|
- 2493 QbeGen.WidenIndex(iq, ql);
|
|
|
- 2494 isOpen :=
|
|
|
- 2495 SymTab.IsOpenArray(t);
|
|
|
- 2496 IF isOpen THEN
|
|
|
- 2497 QbeGen.CopyOp("0", qlo);
|
|
|
- 2498 IF SymTab.IsCharArray(t)
|
|
|
- 2499 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2500 QbeGen.OpenHiChar(q, qhi)
|
|
|
- 2501 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
- 2502 END
|
|
|
- 2503 ELSE
|
|
|
- 2504 lo := SymTab.ArrayLo(t);
|
|
|
- 2505 hi := SymTab.ArrayHi(t);
|
|
|
- 2506 IF SymTab.IsCharArray(t)
|
|
|
- 2507 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2508 hi := hi + 1
|
|
|
- 2509 END;
|
|
|
- 2510 QbeGen.IntStr(lo, qlo);
|
|
|
- 2511 QbeGen.IntStr(hi, qhi)
|
|
|
- 2512 END;
|
|
|
- 2513 QbeGen.CheckRange(ql, qlo,
|
|
|
- 2514 qhi);
|
|
|
- 2515 eT := SymTab.ArrayElem(t);
|
|
|
- 2516 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
- 2517 t, qe);
|
|
|
- 2518 IF SymTab.ClassOf(eT) =
|
|
|
- 2519 SymTab.ClArray THEN
|
|
|
- 2520 QbeGen.ElemLoad(qe, eT, q)
|
|
|
- 2521 ELSE QbeGen.CopyOp(qe, q)
|
|
|
- 2522 END;
|
|
|
- 2523 t := eT; sfx := TRUE
|
|
|
- 2524 END; .) }
|
|
|
- 2525 "]"
|
|
|
- 2526 | "." GetIdent<fn>
|
|
|
- 2527 (. astSel := AST.MakeNode(AST.NkSelector);
|
|
|
- 2528 AST.SetOp(astSel, AST.SelField);
|
|
|
- 2529 AST.SetChild(astSel, 0, AST.MakeLeaf(AST.NkIdent, fn));
|
|
|
- 2530 AST.SetChild(astDes, AST.NChild(astDes), astSel); IF k = SymTab.KindModule THEN
|
|
|
- 2531 (* qualified L.x: materialize
|
|
|
- 2532 the export, then load it *)
|
|
|
- 2533 IF NOT SymTab.MaterializeAlias(n,
|
|
|
- 2534 fn, mal) THEN
|
|
|
- 2535 SemError(201);
|
|
|
- 2536 t := SymTab.InvalidType;
|
|
|
- 2537 QbeGen.CopyOp("0", q)
|
|
|
- 2538 ELSE
|
|
|
- 2539 QbeGen.CopyOp(mal, qn);
|
|
|
- 2540 t := SymTab.SymType(mal);
|
|
|
- 2541 k := SymTab.SymKind(mal);
|
|
|
- 2542 sfx := FALSE;
|
|
|
- 2543 IF k = SymTab.KindProc THEN
|
|
|
- 2544 (* call: ArgList supplies
|
|
|
- 2545 the value *)
|
|
|
- 2546 QbeGen.CopyOp("0", q)
|
|
|
- 2547 ELSIF NOT QbeGen.LoadDesignator(
|
|
|
- 2548 mal, t, k, q) THEN
|
|
|
- 2549 SemError(230);
|
|
|
- 2550 QbeGen.CopyOp("0", q)
|
|
|
- 2551 END
|
|
|
- 2552 END
|
|
|
- 2553 ELSIF t = SymTab.InvalidType THEN
|
|
|
- 2554 ELSIF (SymTab.ClassOf(t) #
|
|
|
- 2555 SymTab.ClRecord)
|
|
|
- 2556 AND (SymTab.ClassOf(t) #
|
|
|
- 2557 SymTab.ClClass) THEN
|
|
|
- 2558 SemError(215);
|
|
|
- 2559 t := SymTab.InvalidType
|
|
|
- 2560 ELSIF (SymTab.ClassOf(t) =
|
|
|
- 2561 SymTab.ClClass)
|
|
|
- 2562 AND SymTab.MethodExists(t, fn) THEN
|
|
|
- 2563 (* obj.Method: bind the
|
|
|
- 2564 method and pass obj as
|
|
|
- 2565 the hidden receiver; q
|
|
|
- 2566 already holds the
|
|
|
- 2567 object's address *)
|
|
|
- 2568 QbeGen.ArmRecv(q);
|
|
|
- 2569 QbeGen.CopyOp(fn, n);
|
|
|
- 2570 QbeGen.CopyOp(fn, qn);
|
|
|
- 2571 methCls := t;
|
|
|
- 2572 k := SymTab.KindProc;
|
|
|
- 2573 t := SymTab.InvalidType
|
|
|
- 2574 ELSIF NOT SymTab.FieldExists(t,
|
|
|
- 2575 fn) THEN
|
|
|
- 2576 SemError(216);
|
|
|
- 2577 t := SymTab.InvalidType
|
|
|
- 2578 ELSE
|
|
|
- 2579 fo := SymTab.FieldOffset(t,
|
|
|
- 2580 fn);
|
|
|
- 2581 t := SymTab.FieldType(t, fn);
|
|
|
- 2582 QbeGen.FieldAddr(q, fo, qe);
|
|
|
- 2583 (* array fields are inline:
|
|
|
- 2584 the field address is the
|
|
|
- 2585 descriptor, like records *)
|
|
|
- 2586 QbeGen.CopyOp(qe, q);
|
|
|
- 2587 sfx := TRUE
|
|
|
- 2588 END; .)
|
|
|
- 2589 | "^"
|
|
|
- 2590 (. astSel := AST.MakeNode(AST.NkSelector);
|
|
|
- 2591 AST.SetOp(astSel, AST.SelDeref);
|
|
|
- 2592 AST.SetChild(astDes, AST.NChild(astDes), astSel); IF t = SymTab.InvalidType THEN
|
|
|
- 2593 ELSIF SymTab.ClassOf(t) #
|
|
|
- 2594 SymTab.ClPtr THEN
|
|
|
- 2595 SemError(219);
|
|
|
- 2596 t := SymTab.InvalidType
|
|
|
- 2597 ELSE
|
|
|
- 2598 bt := SymTab.PtrBase(t);
|
|
|
- 2599 IF bt = SymTab.InvalidType THEN
|
|
|
- 2600 ELSE
|
|
|
- 2601 IF sfx THEN
|
|
|
- 2602 QbeGen.ElemLoad(q, t,
|
|
|
- 2603 qb);
|
|
|
- 2604 QbeGen.CopyOp(qb, q)
|
|
|
- 2605 END;
|
|
|
- 2606 t := bt;
|
|
|
- 2607 (* q holds the pointee
|
|
|
- 2608 address: Fact loads
|
|
|
- 2609 scalars/pointers and uses
|
|
|
- 2610 the address for
|
|
|
- 2611 aggregates; the VAR-actual
|
|
|
- 2612 note is q itself. *)
|
|
|
- 2613 sfx := TRUE
|
|
|
- 2614 END
|
|
|
- 2615 END; .) } (. astCur := astDes; .) .
|
|
|
- 2616 (* Result suffix (ISO component after a function call): `F()^`,
|
|
|
- 2617 `F()[i]`, `F().field`. The call result is in t/q with sfx FALSE
|
|
|
- 2618 (a value, or a descriptor address for aggregates); each component
|
|
|
- 2619 descends one level exactly like the Design components. *)
|
|
|
- 2620 ResultComp<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
|
|
|
- 2621 VAR sfx: BOOLEAN; VAR node: AST.Node> (. VAR it, eT, bt: SymTab.TypeIndex;
|
|
|
- 2622 iq, ql, qlo, qhi, qe, qb:
|
|
|
- 2623 QbeGen.QVal;
|
|
|
- 2624 lo, hi, fo: INTEGER;
|
|
|
- 2625 isOpen: BOOLEAN;
|
|
|
- 2626 fname: SymTab.Name;
|
|
|
- 2627 astWrap, astSel: AST.Node; .)
|
|
|
- 2628 = "[" Expr<it, iq>
|
|
|
- 2629 (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
- 2630 astWrap := AST.MakeNode(
|
|
|
- 2631 AST.NkDesignator);
|
|
|
- 2632 AST.SetChild(astWrap, 0, node);
|
|
|
- 2633 node := astWrap
|
|
|
- 2634 END;
|
|
|
- 2635 AST.SetChild(node, AST.NChild(node),
|
|
|
- 2636 AST.MakeUn(AST.NkSelector,
|
|
|
- 2637 AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
- 2638 ELSIF SymTab.ClassOf(t) #
|
|
|
- 2639 SymTab.ClArray THEN
|
|
|
- 2640 SemError(217);
|
|
|
- 2641 t := SymTab.InvalidType
|
|
|
- 2642 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
- 2643 AND (SymTab.ClassOf(it) # SymTab.ClChar)
|
|
|
- 2644 AND (SymTab.ClassOf(it) # SymTab.ClEnum) THEN
|
|
|
- 2645 SemError(218);
|
|
|
- 2646 t := SymTab.InvalidType
|
|
|
- 2647 ELSE
|
|
|
- 2648 QbeGen.WidenIndex(iq, ql);
|
|
|
- 2649 isOpen :=
|
|
|
- 2650 SymTab.IsOpenArray(t);
|
|
|
- 2651 IF isOpen THEN
|
|
|
- 2652 QbeGen.CopyOp("0", qlo);
|
|
|
- 2653 IF SymTab.IsCharArray(t)
|
|
|
- 2654 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2655 QbeGen.OpenHiChar(q, qhi)
|
|
|
- 2656 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
- 2657 END
|
|
|
- 2658 ELSE
|
|
|
- 2659 lo := SymTab.ArrayLo(t);
|
|
|
- 2660 hi := SymTab.ArrayHi(t);
|
|
|
- 2661 IF SymTab.IsCharArray(t)
|
|
|
- 2662 OR SymTab.IsUCharArray(t) THEN
|
|
|
- 2663 hi := hi + 1
|
|
|
- 2664 END;
|
|
|
- 2665 QbeGen.IntStr(lo, qlo);
|
|
|
- 2666 QbeGen.IntStr(hi, qhi)
|
|
|
- 2667 END;
|
|
|
- 2668 QbeGen.CheckRange(ql, qlo,
|
|
|
- 2669 qhi);
|
|
|
- 2670 eT := SymTab.ArrayElem(t);
|
|
|
- 2671 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
- 2672 t, qe);
|
|
|
- 2673 IF SymTab.ClassOf(eT) =
|
|
|
- 2674 SymTab.ClArray THEN
|
|
|
- 2675 QbeGen.ElemLoad(qe, eT, q)
|
|
|
- 2676 ELSE QbeGen.CopyOp(qe, q)
|
|
|
- 2677 END;
|
|
|
- 2678 t := eT; sfx := TRUE
|
|
|
- 2679 END; .)
|
|
|
- 2680 "]"
|
|
|
- 2681 | "." GetIdent<fname>
|
|
|
- 2682 (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
- 2683 astWrap := AST.MakeNode(
|
|
|
- 2684 AST.NkDesignator);
|
|
|
- 2685 AST.SetChild(astWrap, 0, node);
|
|
|
- 2686 node := astWrap
|
|
|
- 2687 END;
|
|
|
- 2688 AST.SetChild(node, AST.NChild(node),
|
|
|
- 2689 AST.MakeUn(AST.NkSelector,
|
|
|
- 2690 AST.SelField,
|
|
|
- 2691 AST.MakeLeaf(AST.NkIdent,
|
|
|
- 2692 fname))); IF t = SymTab.InvalidType THEN
|
|
|
- 2693 ELSIF (SymTab.ClassOf(t) #
|
|
|
- 2694 SymTab.ClRecord)
|
|
|
- 2695 AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
|
|
|
- 2696 SemError(215);
|
|
|
- 2697 t := SymTab.InvalidType
|
|
|
- 2698 ELSIF NOT SymTab.FieldExists(t,
|
|
|
- 2699 fname) THEN
|
|
|
- 2700 SemError(216);
|
|
|
- 2701 t := SymTab.InvalidType
|
|
|
- 2702 ELSE
|
|
|
- 2703 fo := SymTab.FieldOffset(t,
|
|
|
- 2704 fname);
|
|
|
- 2705 t := SymTab.FieldType(t, fname);
|
|
|
- 2706 QbeGen.FieldAddr(q, fo, qe);
|
|
|
- 2707 QbeGen.CopyOp(qe, q);
|
|
|
- 2708 sfx := TRUE
|
|
|
- 2709 END; .)
|
|
|
- 2710 | "^" (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
- 2711 astWrap := AST.MakeNode(
|
|
|
- 2712 AST.NkDesignator);
|
|
|
- 2713 AST.SetChild(astWrap, 0, node);
|
|
|
- 2714 node := astWrap
|
|
|
- 2715 END;
|
|
|
- 2716 astSel := AST.MakeNode(AST.NkSelector);
|
|
|
- 2717 AST.SetOp(astSel, AST.SelDeref);
|
|
|
- 2718 AST.SetChild(node,
|
|
|
- 2719 AST.NChild(node), astSel); IF t = SymTab.InvalidType THEN
|
|
|
- 2720 ELSIF SymTab.ClassOf(t) #
|
|
|
- 2721 SymTab.ClPtr THEN
|
|
|
- 2722 SemError(219);
|
|
|
- 2723 t := SymTab.InvalidType
|
|
|
- 2724 ELSE
|
|
|
- 2725 bt := SymTab.PtrBase(t);
|
|
|
- 2726 IF bt # SymTab.InvalidType THEN
|
|
|
- 2727 IF sfx THEN
|
|
|
- 2728 QbeGen.ElemLoad(q, t, qb);
|
|
|
- 2729 QbeGen.CopyOp(qb, q)
|
|
|
- 2730 END;
|
|
|
- 2731 t := bt; sfx := TRUE
|
|
|
- 2732 END
|
|
|
- 2733 END; .) .
|
|
|
- 2734 Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 2735 (. VAR t2: SymTab.TypeIndex;
|
|
|
- 2736 op: INTEGER;
|
|
|
- 2737 q2, qt, wl: QbeGen.QVal;
|
|
|
- 2738 astA, astB: AST.Node;
|
|
|
- 2739 astOp: INTEGER;
|
|
|
- 2740 astMade: BOOLEAN;
|
|
|
- 2741 isR: BOOLEAN; .)
|
|
|
- 2742 = SimExpr<t, q> (. astA := astCur; astMade := FALSE; .)
|
|
|
- 2743 [ Rel<op> SimExpr<t2, q2>
|
|
|
- 2744 (. astB := astCur; astMade := TRUE;
|
|
|
- 2745 astOp := AST.OpEq;
|
|
|
- 2746 IF op = SymTab.OpNeq1 THEN astOp := AST.OpNe
|
|
|
- 2747 ELSIF op = SymTab.OpNeq2 THEN astOp := AST.OpNe
|
|
|
- 2748 ELSIF op = SymTab.OpLt THEN astOp := AST.OpLt
|
|
|
- 2749 ELSIF op = SymTab.OpLe THEN astOp := AST.OpLe
|
|
|
- 2750 ELSIF op = SymTab.OpGt THEN astOp := AST.OpGt
|
|
|
- 2751 ELSIF op = SymTab.OpGe THEN astOp := AST.OpGe
|
|
|
- 2752 ELSIF op = SymTab.OpIn THEN astOp := AST.OpIn
|
|
|
- 2753 END;
|
|
|
- 2754 IF op = SymTab.OpIn THEN
|
|
|
- 2755 IF SymTab.InCheck(t, t2) THEN
|
|
|
- 2756 IF (t = SymTab.InvalidType)
|
|
|
- 2757 OR (t2 = SymTab.InvalidType) THEN
|
|
|
- 2758 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
- 2759 ELSE
|
|
|
- 2760 QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
|
|
|
- 2761 SymTab.SetCount(t2), qt);
|
|
|
- 2762 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2763 END
|
|
|
- 2764 ELSE SemError(222); t := SymTab.InvalidType;
|
|
|
- 2765 QbeGen.CopyOp("0", q)
|
|
|
- 2766 END
|
|
|
- 2767 ELSIF SymTab.RelCheck(t, t2, op) THEN
|
|
|
- 2768 IF (t = SymTab.InvalidType)
|
|
|
- 2769 OR (t2 = SymTab.InvalidType) THEN
|
|
|
- 2770 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
- 2771 ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
|
|
|
- 2772 OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
|
|
|
- 2773 IF SymTab.IsFwdVar(t) OR SymTab.IsFwdVar(t2) THEN
|
|
|
- 2774 QbeGen.Cmp(op, q, q2, qt, FALSE);
|
|
|
- 2775 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2776 ELSIF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
|
|
|
- 2777 AND (op # SymTab.OpNeq2) THEN
|
|
|
- 2778 SemError(213); t := SymTab.InvalidType;
|
|
|
- 2779 QbeGen.CopyOp("0", q)
|
|
|
- 2780 ELSE
|
|
|
- 2781 QbeGen.CmpL(op, q, q2, qt);
|
|
|
- 2782 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2783 END
|
|
|
- 2784 ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 2785 OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 2786 QbeGen.CmpSet(op, q, q2,
|
|
|
- 2787 SymTab.SetWords(t), SymTab.SetWords(t2), qt);
|
|
|
- 2788 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2789 ELSIF SymTab.StrCompat(t, t2) THEN
|
|
|
- 2790 QbeGen.StrEq(op, q, q2, qt);
|
|
|
- 2791 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2792 ELSIF SymTab.IsLongFamily(t)
|
|
|
- 2793 OR SymTab.IsLongFamily(t2) THEN
|
|
|
- 2794 IF SymTab.IsIntFamily(t) THEN
|
|
|
- 2795 QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
|
|
|
- 2796 END;
|
|
|
- 2797 IF SymTab.IsIntFamily(t2) THEN
|
|
|
- 2798 QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
|
|
|
- 2799 END;
|
|
|
- 2800 QbeGen.CmpLong(op, q, q2, qt);
|
|
|
- 2801 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
- 2802 ELSE
|
|
|
- 2803 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 2804 t := SymTab.BoolType();
|
|
|
- 2805 QbeGen.Cmp(op, q, q2, qt, isR);
|
|
|
- 2806 QbeGen.CopyOp(qt, q)
|
|
|
- 2807 END
|
|
|
- 2808 ELSE SemError(213); t := SymTab.InvalidType;
|
|
|
- 2809 QbeGen.CopyOp("0", q)
|
|
|
- 2810 END;
|
|
|
- 2811 astCur := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB); .) ]
|
|
|
- 2812 (. IF NOT astMade THEN astCur := astA END; .) .
|
|
|
- 2813 Rel<VAR op: INTEGER>
|
|
|
- 2814 = "=" (. op := SymTab.OpEq; .)
|
|
|
- 2815 | "#" (. op := SymTab.OpNeq1; .)
|
|
|
- 2816 | "<" (. op := SymTab.OpLt; .)
|
|
|
- 2817 | "<=" (. op := SymTab.OpLe; .)
|
|
|
- 2818 | ">" (. op := SymTab.OpGt; .)
|
|
|
- 2819 | ">=" (. op := SymTab.OpGe; .)
|
|
|
- 2820 | "IN" (. op := SymTab.OpIn; .) .
|
|
|
- 2821 SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 2822 (. VAR t2, res2, lt, rt:
|
|
|
- 2823 SymTab.TypeIndex;
|
|
|
- 2824 op: INTEGER;
|
|
|
- 2825 q2, qt, wq, qf, q2a, q2b:
|
|
|
- 2826 QbeGen.QVal;
|
|
|
- 2827 neg, isR, isL, folded:
|
|
|
- 2828 BOOLEAN;
|
|
|
- 2829 fok: BOOLEAN;
|
|
|
- 2830 lw, rw, mw: CARDINAL;
|
|
|
- 2831 lTrue, lNext, lDone, qr, qs: QbeGen.QVal;
|
|
|
- 2832 astA, astB: AST.Node;
|
|
|
- 2833 astSign, astOp: INTEGER; .)
|
|
|
- 2834 = (. neg := FALSE; astSign := 0; .)
|
|
|
- 2835 [ "+" (. neg := TRUE; astSign := 1; .)
|
|
|
- 2836 | "-" (. neg := TRUE; astSign := -1; .) ]
|
|
|
- 2837 Term<t, q> (. astA := astCur; IF neg THEN
|
|
|
- 2838 IF QbeGen.IsImm(q) THEN
|
|
|
- 2839 QbeGen.NegFold(q, q)
|
|
|
- 2840 ELSE QbeGen.NewTemp(qt);
|
|
|
- 2841 QbeGen.NegQ(q, qt,
|
|
|
- 2842 SymTab.ClassOf(t)
|
|
|
- 2843 = SymTab.ClReal);
|
|
|
- 2844 QbeGen.CopyOp(qt, q)
|
|
|
- 2845 END
|
|
|
- 2846 END;
|
|
|
- 2847 IF astSign < 0 THEN
|
|
|
- 2848 astCur := AST.MakeUn(
|
|
|
- 2849 AST.NkUnary, AST.OpSub, astA);
|
|
|
- 2850 astA := astCur
|
|
|
- 2851 END; .)
|
|
|
- 2852 { AddOp<op> (. IF op = SymTab.OpOr THEN
|
|
|
- 2853 QbeGen.DelayBegin END; .)
|
|
|
- 2854 Term<t2, q2> (. astB := astCur; IF op = SymTab.OpOr THEN
|
|
|
- 2855 QbeGen.DelayEnd END; .)
|
|
|
- 2856 (. astOp := AST.OpAdd;
|
|
|
- 2857 IF op = SymTab.OpSub THEN astOp := AST.OpSub
|
|
|
- 2858 ELSIF op = SymTab.OpOr THEN astOp := AST.OpOr END;
|
|
|
- 2859 astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
|
|
|
- 2860 astCur := astA;
|
|
|
- 2861 IF op = SymTab.OpOr THEN
|
|
|
- 2862 (* short-circuit: if q is true the RHS is skipped *)
|
|
|
- 2863 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
- 2864 t := SymTab.BoolType()
|
|
|
- 2865 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
- 2866 IF t # SymTab.InvalidType THEN
|
|
|
- 2867 QbeGen.Slot4(qs);
|
|
|
- 2868 QbeGen.NewLabel(lTrue);
|
|
|
- 2869 QbeGen.NewLabel(lNext);
|
|
|
- 2870 QbeGen.NewLabel(lDone);
|
|
|
- 2871 QbeGen.Jnz(q, lTrue, lNext);
|
|
|
- 2872 QbeGen.EmitLabel(lTrue);
|
|
|
- 2873 QbeGen.StoreW(qs, "1");
|
|
|
- 2874 QbeGen.Jmp(lDone);
|
|
|
- 2875 QbeGen.EmitLabel(lNext);
|
|
|
- 2876 QbeGen.DelayFlush;
|
|
|
- 2877 QbeGen.StoreW(qs, q2);
|
|
|
- 2878 QbeGen.Jmp(lDone);
|
|
|
- 2879 QbeGen.EmitLabel(lDone);
|
|
|
- 2880 QbeGen.LoadW(qs, qr);
|
|
|
- 2881 QbeGen.CopyOp(qr, q)
|
|
|
- 2882 ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
|
|
|
- 2883 END
|
|
|
- 2884 ELSIF (op = SymTab.OpAdd)
|
|
|
- 2885 AND (SymTab.UStrCompat(t, t2)
|
|
|
- 2886 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
|
|
|
- 2887 AND (SymTab.ClassOf(t2) = SymTab.ClUStr))
|
|
|
- 2888 OR ((SymTab.ClassOf(t) = SymTab.ClUStr)
|
|
|
- 2889 AND (SymTab.ClassOf(t2) = SymTab.ClUChar))
|
|
|
- 2890 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
|
|
|
- 2891 AND (SymTab.ClassOf(t2) = SymTab.ClUChar))) THEN
|
|
|
- 2892 (* UString concatenation: a UCHAR operand becomes a
|
|
|
- 2893 1-codepoint UString; the result is a descriptor in the
|
|
|
- 2894 shim's concat buffer. Work on copies so neither
|
|
|
- 2895 operand is clobbered. *)
|
|
|
- 2896 IF SymTab.ClassOf(t) = SymTab.ClUStr THEN
|
|
|
- 2897 QbeGen.CopyOp(q, q2a)
|
|
|
- 2898 ELSE
|
|
|
- 2899 QbeGen.UStrFrom(q, q2a)
|
|
|
- 2900 END;
|
|
|
- 2901 IF SymTab.ClassOf(t2) = SymTab.ClUStr THEN
|
|
|
- 2902 QbeGen.UStrCat(q2a, q2, qt)
|
|
|
- 2903 ELSE
|
|
|
- 2904 QbeGen.UStrFrom(q2, q2b);
|
|
|
- 2905 QbeGen.UStrCat(q2a, q2b, qt)
|
|
|
- 2906 END;
|
|
|
- 2907 t := SymTab.NewUStr();
|
|
|
- 2908 QbeGen.CopyOp(qt, q)
|
|
|
- 2909 ELSIF (op = SymTab.OpAdd)
|
|
|
- 2910 AND (SymTab.StrCompat(t, t2)
|
|
|
- 2911 OR (SymTab.IsStrType(t)
|
|
|
- 2912 AND (SymTab.ClassOf(t2) = SymTab.ClChar))
|
|
|
- 2913 OR ((SymTab.ClassOf(t) = SymTab.ClChar)
|
|
|
- 2914 AND SymTab.IsStrType(t2))) THEN
|
|
|
- 2915 (* string concatenation; a CHAR operand becomes a
|
|
|
- 2916 1-character string literal. When both operands are
|
|
|
- 2917 constants, fold to a single string literal so a
|
|
|
- 2918 constructor element stays compile-time. *)
|
|
|
- 2919 QbeGen.StrFold(q, q2, SymTab.ClassOf(t), SymTab.ClassOf(t2),
|
|
|
- 2920 qt, fok);
|
|
|
- 2921 IF NOT fok THEN
|
|
|
- 2922 IF SymTab.StrCompat(t, t2) THEN
|
|
|
- 2923 QbeGen.StrCat(q, q2, qt)
|
|
|
- 2924 ELSIF SymTab.IsStrType(t) THEN
|
|
|
- 2925 QbeGen.DeclCharStr(q2, qs);
|
|
|
- 2926 QbeGen.StrCat(q, qs, qt)
|
|
|
- 2927 ELSE
|
|
|
- 2928 QbeGen.DeclCharStr(q, qs);
|
|
|
- 2929 QbeGen.StrCat(qs, q2, qt)
|
|
|
- 2930 END
|
|
|
- 2931 END;
|
|
|
- 2932 t := SymTab.NewStr();
|
|
|
- 2933 QbeGen.CopyOp(qt, q)
|
|
|
- 2934 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
- 2935 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 2936 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 2937 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
- 2938 mw := lw;
|
|
|
- 2939 IF rw > mw THEN mw := rw END;
|
|
|
- 2940 IF op = SymTab.OpAdd THEN
|
|
|
- 2941 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
|
|
|
- 2942 ELSE
|
|
|
- 2943 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
|
|
|
- 2944 END;
|
|
|
- 2945 t := SymTab.NewSet(
|
|
|
- 2946 SymTab.NewSubR(0,
|
|
|
- 2947 VAL(INTEGER, mw) * 32 - 1));
|
|
|
- 2948 QbeGen.CopyOp(qt, q)
|
|
|
- 2949 ELSE
|
|
|
- 2950 IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
|
|
|
- 2951 lt := t; rt := t2; t := res2
|
|
|
- 2952 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
- 2953 IF t # SymTab.InvalidType THEN
|
|
|
- 2954 isL := SymTab.IsLongFamily(t);
|
|
|
- 2955 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 2956 folded := FALSE;
|
|
|
- 2957 IF (NOT isL) AND (NOT isR)
|
|
|
- 2958 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
- 2959 IF op = SymTab.OpAdd THEN
|
|
|
- 2960 folded := QbeGen.Fold2(0, q, q2, qf)
|
|
|
- 2961 ELSE
|
|
|
- 2962 folded := QbeGen.Fold2(1, q, q2, qf)
|
|
|
- 2963 END
|
|
|
- 2964 END;
|
|
|
- 2965 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
- 2966 ELSE
|
|
|
- 2967 IF isL THEN
|
|
|
- 2968 IF SymTab.IsIntFamily(lt) THEN
|
|
|
- 2969 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
- 2970 END;
|
|
|
- 2971 IF SymTab.IsIntFamily(rt) THEN
|
|
|
- 2972 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
- 2973 END;
|
|
|
- 2974 QbeGen.NewTemp(qt);
|
|
|
- 2975 IF op = SymTab.OpAdd THEN
|
|
|
- 2976 QbeGen.Op3L("add", qt, q, q2)
|
|
|
- 2977 ELSE
|
|
|
- 2978 QbeGen.Op3L("sub", qt, q, q2)
|
|
|
- 2979 END
|
|
|
- 2980 ELSE
|
|
|
- 2981 QbeGen.NewTemp(qt);
|
|
|
- 2982 IF op = SymTab.OpAdd THEN
|
|
|
- 2983 QbeGen.Op3("add", qt, q, q2, isR)
|
|
|
- 2984 ELSE
|
|
|
- 2985 QbeGen.Op3("sub", qt, q, q2, isR)
|
|
|
- 2986 END
|
|
|
- 2987 END;
|
|
|
- 2988 QbeGen.CopyOp(qt, q)
|
|
|
- 2989 END
|
|
|
- 2990 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 2991 END
|
|
|
- 2992 END; .) } .
|
|
|
- 2993 AddOp<VAR op: INTEGER>
|
|
|
- 2994 = "+" (. op := SymTab.OpAdd; .)
|
|
|
- 2995 | "-" (. op := SymTab.OpSub; .)
|
|
|
- 2996 | "OR" (. op := SymTab.OpOr; .) .
|
|
|
- 2997 Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 2998 (. VAR t2, res2, lt, rt:
|
|
|
- 2999 SymTab.TypeIndex;
|
|
|
- 3000 op: INTEGER;
|
|
|
- 3001 q2, qt, wq, qf:
|
|
|
- 3002 QbeGen.QVal;
|
|
|
- 3003 isR, isL, folded: BOOLEAN;
|
|
|
- 3004 lw, rw, mw: CARDINAL;
|
|
|
- 3005 lNext, lFalse, lDone, qr, qs: QbeGen.QVal;
|
|
|
- 3006 astA, astB: AST.Node;
|
|
|
- 3007 astOp: INTEGER; .)
|
|
|
- 3008 = Fact<t, q> (. astA := astCur; .) { MulOp<op> (. IF op = SymTab.OpAnd THEN
|
|
|
- 3009 QbeGen.DelayBegin END; .)
|
|
|
- 3010 Fact<t2, q2> (. astB := astCur; IF op = SymTab.OpAnd THEN
|
|
|
- 3011 QbeGen.DelayEnd END; .)
|
|
|
- 3012 (. astOp := AST.OpMul;
|
|
|
- 3013 IF op = SymTab.OpSlash THEN astOp := AST.OpDiv
|
|
|
- 3014 ELSIF op = SymTab.OpDiv THEN astOp := AST.OpDiv
|
|
|
- 3015 ELSIF op = SymTab.OpMod THEN astOp := AST.OpMod
|
|
|
- 3016 ELSIF op = SymTab.OpAnd THEN astOp := AST.OpAnd END;
|
|
|
- 3017 astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
|
|
|
- 3018 astCur := astA;
|
|
|
- 3019 IF op = SymTab.OpAnd THEN
|
|
|
- 3020 (* short-circuit: if q is false the RHS is skipped *)
|
|
|
- 3021 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
- 3022 t := SymTab.BoolType()
|
|
|
- 3023 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
- 3024 IF t # SymTab.InvalidType THEN
|
|
|
- 3025 QbeGen.Slot4(qs);
|
|
|
- 3026 QbeGen.NewLabel(lNext);
|
|
|
- 3027 QbeGen.NewLabel(lFalse);
|
|
|
- 3028 QbeGen.NewLabel(lDone);
|
|
|
- 3029 QbeGen.Jnz(q, lNext, lFalse);
|
|
|
- 3030 QbeGen.EmitLabel(lNext);
|
|
|
- 3031 QbeGen.DelayFlush;
|
|
|
- 3032 QbeGen.StoreW(qs, q2);
|
|
|
- 3033 QbeGen.Jmp(lDone);
|
|
|
- 3034 QbeGen.EmitLabel(lFalse);
|
|
|
- 3035 QbeGen.StoreW(qs, "0");
|
|
|
- 3036 QbeGen.Jmp(lDone);
|
|
|
- 3037 QbeGen.EmitLabel(lDone);
|
|
|
- 3038 QbeGen.LoadW(qs, qr);
|
|
|
- 3039 QbeGen.CopyOp(qr, q)
|
|
|
- 3040 ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
|
|
|
- 3041 END
|
|
|
- 3042 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
- 3043 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
- 3044 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
- 3045 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
- 3046 mw := lw;
|
|
|
- 3047 IF rw > mw THEN mw := rw END;
|
|
|
- 3048 IF op = SymTab.OpTimes THEN
|
|
|
- 3049 QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
|
|
|
- 3050 ELSE
|
|
|
- 3051 QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
|
|
|
- 3052 END;
|
|
|
- 3053 t := SymTab.NewSet(
|
|
|
- 3054 SymTab.NewSubR(0,
|
|
|
- 3055 VAL(INTEGER, mw) * 32 - 1));
|
|
|
- 3056 QbeGen.CopyOp(qt, q)
|
|
|
- 3057 ELSE
|
|
|
- 3058 IF SymTab.ArithCheck(t, t2,
|
|
|
- 3059 (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
|
|
|
- 3060 res2) THEN
|
|
|
- 3061 lt := t; rt := t2; t := res2
|
|
|
- 3062 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
- 3063 IF t # SymTab.InvalidType THEN
|
|
|
- 3064 isL := SymTab.IsLongFamily(t);
|
|
|
- 3065 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
- 3066 folded := FALSE;
|
|
|
- 3067 IF (NOT isL) AND (NOT isR)
|
|
|
- 3068 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
- 3069 IF op = SymTab.OpTimes THEN
|
|
|
- 3070 folded := QbeGen.Fold2(2, q, q2, qf)
|
|
|
- 3071 ELSIF op = SymTab.OpDiv THEN
|
|
|
- 3072 folded := QbeGen.Fold2(3, q, q2, qf)
|
|
|
- 3073 ELSIF op = SymTab.OpMod THEN
|
|
|
- 3074 folded := QbeGen.Fold2(4, q, q2, qf)
|
|
|
- 3075 END
|
|
|
- 3076 END;
|
|
|
- 3077 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
- 3078 ELSE
|
|
|
- 3079 IF isL THEN
|
|
|
- 3080 IF SymTab.IsIntFamily(lt) THEN
|
|
|
- 3081 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
- 3082 END;
|
|
|
- 3083 IF SymTab.IsIntFamily(rt) THEN
|
|
|
- 3084 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
- 3085 END;
|
|
|
- 3086 QbeGen.NewTemp(qt);
|
|
|
- 3087 IF op = SymTab.OpTimes THEN
|
|
|
- 3088 QbeGen.Op3L("mul", qt, q, q2)
|
|
|
- 3089 ELSIF (op = SymTab.OpDiv)
|
|
|
- 3090 OR (op = SymTab.OpSlash) THEN
|
|
|
- 3091 QbeGen.Op3L("div", qt, q, q2)
|
|
|
- 3092 ELSE
|
|
|
- 3093 QbeGen.Op3L("rem", qt, q, q2)
|
|
|
- 3094 END
|
|
|
- 3095 ELSE
|
|
|
- 3096 QbeGen.NewTemp(qt);
|
|
|
- 3097 IF op = SymTab.OpTimes THEN
|
|
|
- 3098 QbeGen.Op3("mul", qt, q, q2, isR)
|
|
|
- 3099 ELSIF (op = SymTab.OpDiv)
|
|
|
- 3100 OR (op = SymTab.OpSlash) THEN
|
|
|
- 3101 QbeGen.Op3("div", qt, q, q2, isR)
|
|
|
- 3102 ELSE
|
|
|
- 3103 QbeGen.Op3("rem", qt, q, q2, isR)
|
|
|
- 3104 END
|
|
|
- 3105 END;
|
|
|
- 3106 QbeGen.CopyOp(qt, q)
|
|
|
- 3107 END
|
|
|
- 3108 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 3109 END
|
|
|
- 3110 END; .) } .
|
|
|
- 3111 MulOp<VAR op: INTEGER>
|
|
|
- 3112 = "*" (. op := SymTab.OpTimes; .)
|
|
|
- 3113 | "/" (. op := SymTab.OpSlash; .)
|
|
|
- 3114 | "DIV" (. op := SymTab.OpDiv; .)
|
|
|
- 3115 | "MOD" (. op := SymTab.OpMod; .)
|
|
|
- 3116 | ( "AND" | "&" ) (. op := SymTab.OpAnd; .) .
|
|
|
- 3117 Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 3118 (. VAR s: ARRAY [0 .. 255] OF CHAR;
|
|
|
- 3119 et, dt, t2, st, ct2, et2:
|
|
|
- 3120 SymTab.TypeIndex;
|
|
|
- 3121 dk: INTEGER;
|
|
|
- 3122 qd, q2, sq, qa, qm0, qr, qt:
|
|
|
- 3123 QbeGen.QVal;
|
|
|
- 3124 qn, vn: SymTab.Name;
|
|
|
- 3125 vt: SymTab.TypeIndex;
|
|
|
- 3126 c1, c2: INTEGER;
|
|
|
- 3127 lo, hi: INTEGER;
|
|
|
- 3128 isMax: BOOLEAN;
|
|
|
- 3129 called, isHigh, sfx, isCh,
|
|
|
- 3130 isU, uok, isStr: BOOLEAN;
|
|
|
- 3131 ucp: INTEGER; astIsLit: BOOLEAN;
|
|
|
- 3132 astD: AST.Node;
|
|
|
- 3133 astCall: BOOLEAN;
|
|
|
- 3134 astNode, astNot: AST.Node;
|
|
|
- 3135 j: CARDINAL;
|
|
|
- 3136 astArg2: AST.Node;
|
|
|
- 3137 astBrace: AST.Node;
|
|
|
- 3138 astRes: AST.Node; .)
|
|
|
- 3139 = (. astIsLit := FALSE; .)
|
|
|
- 3140 ( integer (. LexString(s);
|
|
|
- 3141 QbeGen.NormInt(s, q); IF twoPhase THEN astIsLit := TRUE; astCur := AST.MakeLeaf(AST.NkIntLit, s) END;
|
|
|
- 3142 t := SymTab.IntType(); .)
|
|
|
- 3143 | charConst (. LexString(s);
|
|
|
- 3144 QbeGen.NormLit(s, q, isCh);
|
|
|
- 3145 IF twoPhase THEN
|
|
|
- 3146 astIsLit := TRUE;
|
|
|
- 3147 astCur := AST.MakeLeaf(
|
|
|
- 3148 AST.NkCharLit, s)
|
|
|
- 3149 END;
|
|
|
- 3150 t := SymTab.CharType(); .)
|
|
|
- 3151 | real (. LexString(s);
|
|
|
- 3152 QbeGen.NormReal(s, q);
|
|
|
- 3153 IF twoPhase THEN
|
|
|
- 3154 astIsLit := TRUE;
|
|
|
- 3155 astCur := AST.MakeLeaf(
|
|
|
- 3156 AST.NkRealLit, s)
|
|
|
- 3157 END;
|
|
|
- 3158 t := SymTab.RealType(); .)
|
|
|
- 3159 | string (. LexString(s);
|
|
|
- 3160 IF twoPhase THEN
|
|
|
- 3161 astIsLit := TRUE;
|
|
|
- 3162 astCur := AST.MakeLeaf(
|
|
|
- 3163 AST.NkStrLit, s)
|
|
|
- 3164 END;
|
|
|
- 3165 IF SymTab.StrLen(s) = 3 THEN
|
|
|
- 3166 t := SymTab.CharType();
|
|
|
- 3167 QbeGen.IntStr(
|
|
|
- 3168 QbeGen.CharVal(s), q)
|
|
|
- 3169 ELSE t := SymTab.NewStr();
|
|
|
- 3170 QbeGen.DeclStr(s, q);
|
|
|
- 3171 (* a literal's value IS its
|
|
|
- 3172 static descriptor address *)
|
|
|
- 3173 QbeGen.NoteAddr(q, q)
|
|
|
- 3174 END; .)
|
|
|
- 3175 | ustring (. LexString(s);
|
|
|
- 3176 IF twoPhase THEN
|
|
|
- 3177 astIsLit := TRUE;
|
|
|
- 3178 astCur := AST.MakeLeaf(
|
|
|
- 3179 AST.NkStrLit, s)
|
|
|
- 3180 END;
|
|
|
- 3181 QbeGen.DeclUStr(s, q, isU, ucp,
|
|
|
- 3182 uok);
|
|
|
- 3183 IF NOT uok THEN
|
|
|
- 3184 SemError(234);
|
|
|
- 3185 t := SymTab.InvalidType
|
|
|
- 3186 ELSIF isU THEN
|
|
|
- 3187 t := SymTab.UCharType();
|
|
|
- 3188 QbeGen.IntStr(ucp, q)
|
|
|
- 3189 ELSE
|
|
|
- 3190 t := SymTab.NewUStr();
|
|
|
- 3191 QbeGen.NoteAddr(q, q)
|
|
|
- 3192 END; .)
|
|
|
- 3193 | Design<dt, dk, qd, qn, sfx> (. astD := astCur; astCall := FALSE; astBrace := AST.NoNode;
|
|
|
- 3194 astNArgs := 0; called := FALSE;
|
|
|
- 3195 t := dt;
|
|
|
- 3196 IF sfx THEN
|
|
|
- 3197 IF dt =
|
|
|
- 3198 SymTab.InvalidType THEN
|
|
|
- 3199 QbeGen.CopyOp("0", q)
|
|
|
- 3200 ELSIF (SymTab.ClassOf(dt) =
|
|
|
- 3201 SymTab.ClRecord)
|
|
|
- 3202 OR (SymTab.ClassOf(dt) =
|
|
|
- 3203 SymTab.ClSet)
|
|
|
- 3204 OR (SymTab.ClassOf(dt) =
|
|
|
- 3205 SymTab.ClArray)
|
|
|
- 3206 OR (SymTab.ClassOf(dt) =
|
|
|
- 3207 SymTab.ClClass) THEN
|
|
|
- 3208 QbeGen.CopyOp(qd, q)
|
|
|
- 3209 ELSE QbeGen.ElemLoad(qd, dt,
|
|
|
- 3210 q)
|
|
|
- 3211 END
|
|
|
- 3212 ELSE QbeGen.CopyOp(qd, q)
|
|
|
- 3213 END;
|
|
|
- 3214 IF (dk = SymTab.KindVar)
|
|
|
- 3215 OR (dk = SymTab.KindParam)
|
|
|
- 3216 OR (dk =
|
|
|
- 3217 SymTab.KindField) THEN
|
|
|
- 3218 IF sfx THEN
|
|
|
- 3219 QbeGen.NoteAddr(q, qd)
|
|
|
- 3220 ELSE
|
|
|
- 3221 QbeGen.AddrOf(qn, qa);
|
|
|
- 3222 QbeGen.NoteAddr(q, qa)
|
|
|
- 3223 END
|
|
|
- 3224 ELSIF sfx
|
|
|
- 3225 AND (dt #
|
|
|
- 3226 SymTab.InvalidType)
|
|
|
- 3227 AND ((SymTab.ClassOf(dt) =
|
|
|
- 3228 SymTab.ClArray)
|
|
|
- 3229 OR (SymTab.ClassOf(dt) =
|
|
|
- 3230 SymTab.ClSet)
|
|
|
- 3231 OR (SymTab.ClassOf(dt) =
|
|
|
- 3232 SymTab.ClRecord)) THEN
|
|
|
- 3233 QbeGen.NoteAddr(qd, qd)
|
|
|
- 3234 END; .)
|
|
|
- 3235 [ TypedBraceLit<dt, q> (. t := dt; astCall := TRUE;
|
|
|
- 3236 astBrace := astCur; .) ]
|
|
|
- 3237 [ ArgList<qn, dt, qd, TRUE, FALSE, methCls, ct2, q2, called>
|
|
|
- 3238 (. astCall := TRUE;
|
|
|
- 3239 astNode := AstCallNode(astD);
|
|
|
- 3240 astRes := astNode;
|
|
|
- 3241 t := ct2;
|
|
|
- 3242 QbeGen.CopyOp(q2, q);
|
|
|
- 3243 sfx := FALSE; .)
|
|
|
- 3244 { ResultComp<t, q, sfx, astRes> }
|
|
|
- 3245 (. IF sfx THEN
|
|
|
- 3246 IF t = SymTab.InvalidType THEN
|
|
|
- 3247 QbeGen.CopyOp("0", q)
|
|
|
- 3248 ELSIF (SymTab.ClassOf(t) #
|
|
|
- 3249 SymTab.ClRecord)
|
|
|
- 3250 AND (SymTab.ClassOf(t) # SymTab.ClSet)
|
|
|
- 3251 AND (SymTab.ClassOf(t) # SymTab.ClArray)
|
|
|
- 3252 AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
|
|
|
- 3253 QbeGen.ElemLoad(q, t, q2);
|
|
|
- 3254 QbeGen.CopyOp(q2, q)
|
|
|
- 3255 END
|
|
|
- 3256 END; .) ]
|
|
|
- 3257 (. IF called THEN
|
|
|
- 3258 astCur := astRes
|
|
|
- 3259 ELSIF astCall THEN
|
|
|
- 3260 astCur := astBrace
|
|
|
- 3261 ELSE astCur := astD
|
|
|
- 3262 END;
|
|
|
- 3263 astIsLit := TRUE;
|
|
|
- 3264 IF NOT called
|
|
|
- 3265 AND (dk = SymTab.KindProc) THEN
|
|
|
- 3266 (* bare zero-arg function
|
|
|
- 3267 call (parentheses may be
|
|
|
- 3268 omitted); a proper or
|
|
|
- 3269 parameterised proc here
|
|
|
- 3270 is 230 *)
|
|
|
- 3271 IF (SymTab.ProcNPar(qn) = 0)
|
|
|
- 3272 AND (SymTab.ProcRes(qn) #
|
|
|
- 3273 SymTab.InvalidType) THEN
|
|
|
- 3274 QbeGen.Mangled(qn,
|
|
|
- 3275 SymTab.ProcUid(qn), qm0);
|
|
|
- 3276 QbeGen.CallBegin(qm0,
|
|
|
- 3277 SymTab.ProcRes(qn),
|
|
|
- 3278 SymTab.ProcDepthOf(qn),
|
|
|
- 3279 SymTab.IsExternal(qn));
|
|
|
- 3280 QbeGen.CallEnd(TRUE, q);
|
|
|
- 3281 t := SymTab.ProcRes(qn)
|
|
|
- 3282 ELSE
|
|
|
- 3283 (* procedure used as a
|
|
|
- 3284 value (assign to a
|
|
|
- 3285 procedure variable):
|
|
|
- 3286 its code address *)
|
|
|
- 3287 t := SymTab.ProcTypeOf(qn);
|
|
|
- 3288 QbeGen.Mangled(qn,
|
|
|
- 3289 SymTab.ProcUid(qn), qm0);
|
|
|
- 3290 QbeGen.ProcAddr(qm0, q)
|
|
|
- 3291 END
|
|
|
- 3292 END; .)
|
|
|
- 3293 | ( "HIGH" (. isHigh := TRUE; .)
|
|
|
- 3294 | ( "LEN" | "LENGTH" ) (. isHigh := FALSE; .) )
|
|
|
- 3295 "(" ( Design<dt, dk, qd, qn, sfx> (. isStr := FALSE;
|
|
|
- 3296 isU := FALSE; .)
|
|
|
- 3297 | string (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
|
|
|
- 3298 isStr := TRUE;
|
|
|
- 3299 isU := FALSE;
|
|
|
- 3300 IF SymTab.StrLen(s) = 3 THEN
|
|
|
- 3301 dt := SymTab.CharType();
|
|
|
- 3302 QbeGen.IntStr(QbeGen.CharVal(s),
|
|
|
- 3303 qd)
|
|
|
- 3304 ELSE
|
|
|
- 3305 dt := SymTab.NewStr();
|
|
|
- 3306 QbeGen.DeclStr(s, qd);
|
|
|
- 3307 QbeGen.NoteAddr(qd, qd)
|
|
|
- 3308 END;
|
|
|
- 3309 dk := -1;
|
|
|
- 3310 qn[0] := CHR(0); .)
|
|
|
- 3311 | ustring (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
|
|
|
- 3312 QbeGen.DeclUStr(s, qd, isU, ucp,
|
|
|
- 3313 uok);
|
|
|
- 3314 isStr := FALSE;
|
|
|
- 3315 IF NOT uok THEN
|
|
|
- 3316 SemError(234);
|
|
|
- 3317 dt := SymTab.InvalidType
|
|
|
- 3318 ELSIF isU THEN
|
|
|
- 3319 (* one codepoint: a UCHAR;
|
|
|
- 3320 LEN is 1, HIGH is 0 *)
|
|
|
- 3321 dt := SymTab.UCharType();
|
|
|
- 3322 QbeGen.IntStr(ucp, qd)
|
|
|
- 3323 ELSE
|
|
|
- 3324 dt := SymTab.NewUStr();
|
|
|
- 3325 QbeGen.NoteAddr(qd, qd)
|
|
|
- 3326 END;
|
|
|
- 3327 dk := -1;
|
|
|
- 3328 qn[0] := CHR(0); .) )
|
|
|
- 3329 ")"
|
|
|
- 3330 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3331 IF isHigh THEN AST.SetChild(astNode, 0,
|
|
|
- 3332 AST.MakeLeaf(AST.NkIdent, "HIGH"))
|
|
|
- 3333 ELSE AST.SetChild(astNode, 0,
|
|
|
- 3334 AST.MakeLeaf(AST.NkIdent, "LEN")) END;
|
|
|
- 3335 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3336 astCur := astNode; astIsLit := TRUE;
|
|
|
- 3337 IF (dt # SymTab.InvalidType)
|
|
|
- 3338 AND (SymTab.ClassOf(dt) = SymTab.ClUStr) THEN
|
|
|
- 3339 (* UString: the count is
|
|
|
- 3340 the descriptor header *)
|
|
|
- 3341 IF isHigh THEN
|
|
|
- 3342 QbeGen.UStrLen(qd, qr);
|
|
|
- 3343 QbeGen.DecQ(qr)
|
|
|
- 3344 ELSE
|
|
|
- 3345 QbeGen.UStrLen(qd, qr)
|
|
|
- 3346 END;
|
|
|
- 3347 t := SymTab.IntType();
|
|
|
- 3348 QbeGen.CopyOp(qr, q)
|
|
|
- 3349 ELSIF (dt # SymTab.InvalidType)
|
|
|
- 3350 AND (SymTab.ClassOf(dt) = SymTab.ClUChar) THEN
|
|
|
- 3351 (* single UCHAR codepoint *)
|
|
|
- 3352 IF isHigh THEN
|
|
|
- 3353 QbeGen.CopyOp("0", qr)
|
|
|
- 3354 ELSE
|
|
|
- 3355 QbeGen.CopyOp("1", qr)
|
|
|
- 3356 END;
|
|
|
- 3357 t := SymTab.IntType();
|
|
|
- 3358 QbeGen.CopyOp(qr, q)
|
|
|
- 3359 ELSIF isStr THEN
|
|
|
- 3360 (* fold: content length at
|
|
|
- 3361 compile time *)
|
|
|
- 3362 IF SymTab.StrLen(s) = 3 THEN
|
|
|
- 3363 c1 := 1
|
|
|
- 3364 ELSE
|
|
|
- 3365 c1 :=
|
|
|
- 3366 SymTab.StrLen(s) - 2
|
|
|
- 3367 END;
|
|
|
- 3368 IF isHigh THEN
|
|
|
- 3369 DEC(c1)
|
|
|
- 3370 END;
|
|
|
- 3371 QbeGen.IntStr(c1, qr);
|
|
|
- 3372 t := SymTab.IntType();
|
|
|
- 3373 QbeGen.CopyOp(qr, q)
|
|
|
- 3374 ELSIF dt = SymTab.InvalidType THEN
|
|
|
- 3375 t := SymTab.InvalidType;
|
|
|
- 3376 QbeGen.CopyOp("0", q)
|
|
|
- 3377 ELSIF SymTab.ClassOf(dt) #
|
|
|
- 3378 SymTab.ClArray THEN
|
|
|
- 3379 SemError(217);
|
|
|
- 3380 t := SymTab.InvalidType;
|
|
|
- 3381 QbeGen.CopyOp("0", q)
|
|
|
- 3382 ELSE
|
|
|
- 3383 IF isHigh THEN
|
|
|
- 3384 IF SymTab.IsOpenArray(dt) THEN
|
|
|
- 3385 QbeGen.OpenHi(qd, qr)
|
|
|
- 3386 ELSE
|
|
|
- 3387 QbeGen.IntStr(
|
|
|
- 3388 SymTab.ArrayHi(dt), qr)
|
|
|
- 3389 END
|
|
|
- 3390 ELSE
|
|
|
- 3391 IF SymTab.IsOpenArray(dt) THEN
|
|
|
- 3392 QbeGen.LoadCount(qd, qr)
|
|
|
- 3393 ELSE
|
|
|
- 3394 QbeGen.IntStr(VAL(
|
|
|
- 3395 INTEGER,
|
|
|
- 3396 SymTab.ArrayLen(dt)),
|
|
|
- 3397 qr)
|
|
|
- 3398 END
|
|
|
- 3399 END;
|
|
|
- 3400 t := SymTab.IntType();
|
|
|
- 3401 QbeGen.CopyOp(qr, q)
|
|
|
- 3402 END; .)
|
|
|
- 3403 | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 3404 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3405 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "SIZE"));
|
|
|
- 3406 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3407 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3408 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 3409 t := SymTab.InvalidType;
|
|
|
- 3410 QbeGen.CopyOp("0", q)
|
|
|
- 3411 ELSE
|
|
|
- 3412 QbeGen.IntStr(VAL(INTEGER,
|
|
|
- 3413 SymTab.ObjectSize(dt)), q);
|
|
|
- 3414 t := SymTab.IntType()
|
|
|
- 3415 END; .)
|
|
|
- 3416 | ( "SHIFT" (. isMax := FALSE; .)
|
|
|
- 3417 | "ROTATE" (. isMax := TRUE; .) )
|
|
|
- 3418 "(" Expr<et, q> (. astArg2 := astCur; .) "," Expr<et2, q2> ")"
|
|
|
- 3419 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3420 IF isMax THEN AST.SetChild(astNode, 0,
|
|
|
- 3421 AST.MakeLeaf(AST.NkIdent, "ROTATE"))
|
|
|
- 3422 ELSE AST.SetChild(astNode, 0,
|
|
|
- 3423 AST.MakeLeaf(AST.NkIdent, "SHIFT")) END;
|
|
|
- 3424 IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
|
|
|
- 3425 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
|
|
|
- 3426 astCur := astNode; astIsLit := TRUE;
|
|
|
- 3427 (* set shift/rotate: isMax
|
|
|
- 3428 doubles as "rotate" *)
|
|
|
- 3429 IF (et # SymTab.InvalidType)
|
|
|
- 3430 AND (SymTab.ClassOf(et) =
|
|
|
- 3431 SymTab.ClSet) THEN
|
|
|
- 3432 QbeGen.SetShift(q, q2,
|
|
|
- 3433 SymTab.SetWords(et),
|
|
|
- 3434 SymTab.SetCount(et), isMax,
|
|
|
- 3435 qt);
|
|
|
- 3436 t := et;
|
|
|
- 3437 QbeGen.CopyOp(qt, q)
|
|
|
- 3438 ELSE SemError(230);
|
|
|
- 3439 t := SymTab.InvalidType;
|
|
|
- 3440 QbeGen.CopyOp("0", q)
|
|
|
- 3441 END; .)
|
|
|
- 3442 | ( "MIN" (. isMax := FALSE; .)
|
|
|
- 3443 | "MAX" (. isMax := TRUE; .) )
|
|
|
- 3444 "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 3445 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3446 IF isMax THEN AST.SetChild(astNode, 0,
|
|
|
- 3447 AST.MakeLeaf(AST.NkIdent, "MAX"))
|
|
|
- 3448 ELSE AST.SetChild(astNode, 0,
|
|
|
- 3449 AST.MakeLeaf(AST.NkIdent, "MIN")) END;
|
|
|
- 3450 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3451 astCur := astNode; astIsLit := TRUE;
|
|
|
- 3452 IF (dt # SymTab.InvalidType)
|
|
|
- 3453 AND (SymTab.ClassOf(dt) = SymTab.ClReal) THEN
|
|
|
- 3454 (* REAL/LONGREAL: the
|
|
|
- 3455 implementation bounds *)
|
|
|
- 3456 IF isMax THEN
|
|
|
- 3457 QbeGen.NormReal(
|
|
|
- 3458 "3.402823e38", q)
|
|
|
- 3459 ELSE QbeGen.NormReal(
|
|
|
- 3460 "-3.402823e38", q)
|
|
|
- 3461 END;
|
|
|
- 3462 t := SymTab.RealType()
|
|
|
- 3463 ELSIF (dt #
|
|
|
- 3464 SymTab.InvalidType)
|
|
|
- 3465 AND (SymTab.ClassOf(dt) =
|
|
|
- 3466 SymTab.ClLong) THEN
|
|
|
- 3467 IF isMax THEN
|
|
|
- 3468 QbeGen.CopyOp(
|
|
|
- 3469 "9223372036854775807", q)
|
|
|
- 3470 ELSE QbeGen.CopyOp(
|
|
|
- 3471 "-9223372036854775808", q)
|
|
|
- 3472 END;
|
|
|
- 3473 t := SymTab.LongType()
|
|
|
- 3474 ELSIF SymTab.TypeBounds(dt, lo,
|
|
|
- 3475 hi) THEN
|
|
|
- 3476 IF isMax THEN
|
|
|
- 3477 QbeGen.IntStr(hi, q)
|
|
|
- 3478 ELSE QbeGen.IntStr(lo, q)
|
|
|
- 3479 END;
|
|
|
- 3480 t := SymTab.IntType()
|
|
|
- 3481 ELSE SemError(230);
|
|
|
- 3482 t := SymTab.InvalidType;
|
|
|
- 3483 QbeGen.CopyOp("0", q)
|
|
|
- 3484 END; .)
|
|
|
- 3485 | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
- 3486 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3487 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ADR"));
|
|
|
- 3488 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3489 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3490 (. IF dt = SymTab.InvalidType THEN
|
|
|
- 3491 t := SymTab.InvalidType;
|
|
|
- 3492 QbeGen.CopyOp("0", q)
|
|
|
- 3493 ELSE
|
|
|
- 3494 IF sfx THEN
|
|
|
- 3495 QbeGen.CopyOp(qd, q)
|
|
|
- 3496 ELSIF (dk = SymTab.KindVar)
|
|
|
- 3497 OR (dk = SymTab.KindParam) THEN
|
|
|
- 3498 QbeGen.AddrOf(qn, q)
|
|
|
- 3499 ELSE SemError(230);
|
|
|
- 3500 QbeGen.CopyOp("0", q)
|
|
|
- 3501 END;
|
|
|
- 3502 t := SymTab.AddrType()
|
|
|
- 3503 END; .)
|
|
|
- 3504 | "CHR" "(" Expr<et, q> ")"
|
|
|
- 3505 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3506 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR"));
|
|
|
- 3507 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3508 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3509 (. IF (et # SymTab.InvalidType)
|
|
|
- 3510 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
- 3511 SemError(211) END;
|
|
|
- 3512 t := SymTab.CharType(); .)
|
|
|
- 3513 | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
|
|
|
- 3514 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3515 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ORD"));
|
|
|
- 3516 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3517 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3518 (. IF et # SymTab.InvalidType THEN
|
|
|
- 3519 IF (SymTab.ClassOf(et) #
|
|
|
- 3520 SymTab.ClChar)
|
|
|
- 3521 AND (SymTab.ClassOf(et) #
|
|
|
- 3522 SymTab.ClBool)
|
|
|
- 3523 AND (SymTab.ClassOf(et) #
|
|
|
- 3524 SymTab.ClEnum)
|
|
|
- 3525 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
- 3526 SemError(211) END
|
|
|
- 3527 END;
|
|
|
- 3528 t := SymTab.IntType(); .)
|
|
|
- 3529 | "CAP" "(" Expr<et, q> ")"
|
|
|
- 3530 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3531 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CAP"));
|
|
|
- 3532 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3533 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3534 (. QbeGen.CapQ(q, qa);
|
|
|
- 3535 QbeGen.CopyOp(qa, q);
|
|
|
- 3536 t := SymTab.CharType(); .)
|
|
|
- 3537 | "UCHR" "(" Expr<et, q> ")"
|
|
|
- 3538 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3539 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UCHR"));
|
|
|
- 3540 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3541 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3542 (. (* UCHR: the UCHAR constructor.
|
|
|
- 3543 CHAR -> UCHAR (identity);
|
|
|
- 3544 INTEGER familly -> UCHAR
|
|
|
- 3545 (codepoint value). *)
|
|
|
- 3546 IF (et # SymTab.InvalidType)
|
|
|
- 3547 AND (SymTab.ClassOf(et) # SymTab.ClChar)
|
|
|
- 3548 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
- 3549 SemError(211) END;
|
|
|
- 3550 t := SymTab.UCharType(); .)
|
|
|
- 3551 | "CHR8" "(" Expr<et, q> ")"
|
|
|
- 3552 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3553 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR8"));
|
|
|
- 3554 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3555 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3556 (. IF (et # SymTab.InvalidType)
|
|
|
- 3557 AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
|
|
|
- 3558 SemError(211) END;
|
|
|
- 3559 QbeGen.WidenLong(q, qa);
|
|
|
- 3560 QbeGen.CheckRange(qa, "0", "255");
|
|
|
- 3561 t := SymTab.CharType(); .)
|
|
|
- 3562 | "UORD" "(" Expr<et, q> ")"
|
|
|
- 3563 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3564 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UORD"));
|
|
|
- 3565 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3566 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3567 (. (* UORD(u): the codepoint as a
|
|
|
- 3568 32-bit ordinal (INTEGER),
|
|
|
- 3569 cf. ORD for CHAR. *)
|
|
|
- 3570 IF (et # SymTab.InvalidType)
|
|
|
- 3571 AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
|
|
|
- 3572 SemError(211) END;
|
|
|
- 3573 t := SymTab.IntType(); .)
|
|
|
- 3574 | "ABS" "(" Expr<et, q> ")"
|
|
|
- 3575 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3576 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ABS"));
|
|
|
- 3577 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
- 3578 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3579 (. IF (et # SymTab.InvalidType)
|
|
|
- 3580 AND NOT SymTab.IsIntFamily(et)
|
|
|
- 3581 AND (SymTab.ClassOf(et) #
|
|
|
- 3582 SymTab.ClReal) THEN
|
|
|
- 3583 SemError(211)
|
|
|
- 3584 ELSE QbeGen.AbsQ(q, qa,
|
|
|
- 3585 SymTab.ClassOf(et) =
|
|
|
- 3586 SymTab.ClReal);
|
|
|
- 3587 QbeGen.CopyOp(qa, q)
|
|
|
- 3588 END;
|
|
|
- 3589 t := et; .)
|
|
|
- 3590 | "VAL" "(" GetIdent<vn> (. astArg2 := AST.MakeLeaf(AST.NkIdent, vn); .) "," Expr<et, q> ")"
|
|
|
- 3591 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
- 3592 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "VAL"));
|
|
|
- 3593 IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
|
|
|
- 3594 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
|
|
|
- 3595 astCur := astNode; astIsLit := TRUE; .)
|
|
|
- 3596 (. IF NOT SymTab.Lookup(vn) THEN
|
|
|
- 3597 SemError(201);
|
|
|
- 3598 t := SymTab.InvalidType
|
|
|
- 3599 ELSE vt := SymTab.SymType(vn);
|
|
|
- 3600 IF vt = SymTab.InvalidType THEN
|
|
|
- 3601 t := SymTab.InvalidType
|
|
|
- 3602 ELSIF et =
|
|
|
- 3603 SymTab.InvalidType THEN
|
|
|
- 3604 t := vt
|
|
|
- 3605 ELSE
|
|
|
- 3606 c1 := SymTab.ClassOf(et);
|
|
|
- 3607 c2 := SymTab.ClassOf(vt);
|
|
|
- 3608 IF (c1 = SymTab.ClInt)
|
|
|
- 3609 AND (c2 = SymTab.ClLong) THEN
|
|
|
- 3610 QbeGen.WidenLong(q, qa);
|
|
|
- 3611 QbeGen.CopyOp(qa, q);
|
|
|
- 3612 t := vt
|
|
|
- 3613 ELSIF (c1 = SymTab.ClLong)
|
|
|
- 3614 AND (c2 = SymTab.ClInt) THEN
|
|
|
- 3615 QbeGen.NarrowLong(q, qa);
|
|
|
- 3616 QbeGen.CopyOp(qa, q);
|
|
|
- 3617 t := vt
|
|
|
- 3618 ELSIF (c1 = SymTab.ClInt)
|
|
|
- 3619 AND (c2 = SymTab.ClReal) THEN
|
|
|
- 3620 QbeGen.ConvIR(q, qa);
|
|
|
- 3621 QbeGen.CopyOp(qa, q);
|
|
|
- 3622 t := vt
|
|
|
- 3623 ELSIF (c1 = SymTab.ClLong)
|
|
|
- 3624 AND (c2 = SymTab.ClReal) THEN
|
|
|
- 3625 QbeGen.ConvLR(q, qa);
|
|
|
- 3626 QbeGen.CopyOp(qa, q);
|
|
|
- 3627 t := vt
|
|
|
- 3628 ELSIF (c1 = SymTab.ClReal)
|
|
|
- 3629 AND (c2 = SymTab.ClInt) THEN
|
|
|
- 3630 QbeGen.ConvRI(q, qa);
|
|
|
- 3631 QbeGen.CopyOp(qa, q);
|
|
|
- 3632 t := vt
|
|
|
- 3633 ELSIF (c1 = SymTab.ClReal)
|
|
|
- 3634 AND (c2 = SymTab.ClLong) THEN
|
|
|
- 3635 QbeGen.ConvRL(q, qa);
|
|
|
- 3636 QbeGen.CopyOp(qa, q);
|
|
|
- 3637 t := vt
|
|
|
- 3638 ELSIF ((c1 = SymTab.ClInt)
|
|
|
- 3639 OR (c1 =
|
|
|
- 3640 SymTab.ClChar)
|
|
|
- 3641 OR (c1 =
|
|
|
- 3642 SymTab.ClBool)
|
|
|
- 3643 OR (c1 =
|
|
|
- 3644 SymTab.ClEnum))
|
|
|
- 3645 AND ((c2 = SymTab.ClInt)
|
|
|
- 3646 OR (c2 =
|
|
|
- 3647 SymTab.ClChar)
|
|
|
- 3648 OR (c2 =
|
|
|
- 3649 SymTab.ClBool)
|
|
|
- 3650 OR (c2 =
|
|
|
- 3651 SymTab.ClEnum)) THEN
|
|
|
- 3652 t := vt
|
|
|
- 3653 ELSIF (c1 = SymTab.ClPtr)
|
|
|
- 3654 AND (c2 = SymTab.ClPtr) THEN
|
|
|
- 3655 t := vt
|
|
|
- 3656 ELSIF (c1 = SymTab.ClReal)
|
|
|
- 3657 AND (c2 = SymTab.ClReal) THEN
|
|
|
- 3658 t := vt
|
|
|
- 3659 ELSE SemError(230);
|
|
|
- 3660 t := SymTab.InvalidType
|
|
|
- 3661 END
|
|
|
- 3662 END
|
|
|
- 3663 END; .)
|
|
|
- 3664 | "(" Expr<et, q> ")" (. t := et; astIsLit := TRUE; .)
|
|
|
- 3665 | SetLit<st, sq> (. astIsLit := TRUE; t := st;
|
|
|
- 3666 QbeGen.CopyOp(sq, q); .)
|
|
|
- 3667 | ( "NOT" | "~" ) Fact<t2, q2> (. astNot := astCur;
|
|
|
- 3668 IF SymTab.BoolCheck(t2) THEN
|
|
|
- 3669 t := SymTab.BoolType()
|
|
|
- 3670 ELSE SemError(212);
|
|
|
- 3671 t := SymTab.InvalidType END;
|
|
|
- 3672 IF t # SymTab.InvalidType THEN
|
|
|
- 3673 QbeGen.NotQ(q2, q)
|
|
|
- 3674 ELSE QbeGen.CopyOp("0", q)
|
|
|
- 3675 END;
|
|
|
- 3676 astIsLit := TRUE;
|
|
|
- 3677 astCur := AST.MakeUn(
|
|
|
- 3678 AST.NkUnary, AST.OpNot, astNot); .)
|
|
|
- 3679 )
|
|
|
- 3680 (. IF NOT astIsLit THEN astCur := AST.NoNode END; .) .
|
|
|
- 3681 (* Set literals are SET OF [0..255] (8 words); elements validated
|
|
|
- 3682 0..255 statically when foldable (222 otherwise), runtime trap
|
|
|
- 3683 for computed elements. Ranges always lower via SetRange. *)
|
|
|
- 3684 SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 3685 (. VAR astNode: AST.Node; .)
|
|
|
- 3686 = "{" (. t := SymTab.NewSet(
|
|
|
- 3687 SymTab.NewSubR(0, 255));
|
|
|
- 3688 astNode := AST.MakeNode(AST.NkSetLit);
|
|
|
- 3689 QbeGen.NewSetTemp(8, q);
|
|
|
- 3690 QbeGen.SetZero(q, 8); .)
|
|
|
- 3691 [ SetElem<t, q, astNode> { "," SetElem<t, q, astNode> } ]
|
|
|
- 3692 "}" (. astCur := astNode; .) .
|
|
|
- 3693 (* Typed brace constructor: TypeName{ elems } — BITSET{0} (a set)
|
|
|
- 3694 or ArrayName{...} (an array constructor, GNU Modula-2). The
|
|
|
- 3695 declared type sets the width (set) or element type (array). *)
|
|
|
- 3696 TypedBraceLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
- 3697 (. VAR nw: CARDINAL;
|
|
|
- 3698 astNode, astTail: AST.Node;
|
|
|
- 3699 savedCls: INTEGER; .)
|
|
|
- 3700 = "{" (. savedCls := braceCls;
|
|
|
- 3701 astNode := AST.MakeNode(AST.NkBraceLit);
|
|
|
- 3702 AST.SetTy(astNode, vt);
|
|
|
- 3703 astTail := astNode;
|
|
|
- 3704 IF vt = SymTab.InvalidType THEN
|
|
|
- 3705 braceCls := -1
|
|
|
- 3706 ELSE braceCls :=
|
|
|
- 3707 SymTab.ClassOf(vt)
|
|
|
- 3708 END;
|
|
|
- 3709 IF braceCls = SymTab.ClSet THEN
|
|
|
- 3710 IF vt = SymTab.InvalidType THEN
|
|
|
- 3711 nw := 8
|
|
|
- 3712 ELSE nw := SymTab.SetWords(vt);
|
|
|
- 3713 IF nw = 0 THEN nw := 8 END
|
|
|
- 3714 END;
|
|
|
- 3715 QbeGen.NewSetTemp(nw, q);
|
|
|
- 3716 QbeGen.SetZero(q, nw)
|
|
|
- 3717 ELSIF (braceCls =
|
|
|
- 3718 SymTab.ClArray)
|
|
|
- 3719 OR (braceCls =
|
|
|
- 3720 SymTab.ClRecord)
|
|
|
- 3721 OR (braceCls =
|
|
|
- 3722 SymTab.ClClass) THEN
|
|
|
- 3723 QbeGen.CtorBegin(vt)
|
|
|
- 3724 ELSE
|
|
|
- 3725 IF vt # SymTab.InvalidType THEN
|
|
|
- 3726 SemError(230) END;
|
|
|
- 3727 braceCls := -1
|
|
|
- 3728 END; .)
|
|
|
- 3729 [ BraceElem<vt, q, astNode, astTail>
|
|
|
- 3730 { "," BraceElem<vt, q, astNode, astTail> } ]
|
|
|
- 3731 "}" (. IF (braceCls = SymTab.ClArray)
|
|
|
- 3732 OR (braceCls =
|
|
|
- 3733 SymTab.ClRecord)
|
|
|
- 3734 OR (braceCls =
|
|
|
- 3735 SymTab.ClClass) THEN
|
|
|
- 3736 QbeGen.CtorEnd(q)
|
|
|
- 3737 ELSIF braceCls # SymTab.ClSet THEN
|
|
|
- 3738 QbeGen.CopyOp("0", q)
|
|
|
- 3739 END;
|
|
|
- 3740 braceCls := savedCls; .)
|
|
|
- 3741 (. astCur := astNode; .) .
|
|
|
- 3742 BraceElem<vt: SymTab.TypeIndex; VAR sq: QbeGen.QVal;
|
|
|
- 3743 VAR node, tail: AST.Node>
|
|
|
- 3744 (. VAR et, et2: SymTab.TypeIndex;
|
|
|
- 3745 qe, q2: QbeGen.QVal;
|
|
|
- 3746 v, v2, reps, k: INTEGER;
|
|
|
- 3747 elem: SymTab.TypeIndex;
|
|
|
- 3748 lo: INTEGER;
|
|
|
- 3749 span: CARDINAL;
|
|
|
- 3750 cl, cl2: INTEGER;
|
|
|
- 3751 hasR, hasB: BOOLEAN;
|
|
|
- 3752 astEl: AST.Node; .)
|
|
|
- 3753 = (. hasR := FALSE; hasB := FALSE;
|
|
|
- 3754 reps := 1; .)
|
|
|
- 3755 Expr<et, qe> (. astEl := astCur; .)
|
|
|
- 3756 [ ".." Expr<et2, q2> (. astEl := AST.MakeBin(
|
|
|
- 3757 AST.NkSubrange, 0, astEl, astCur);
|
|
|
- 3758 hasR := TRUE; .) ]
|
|
|
- 3759 [ "BY" Expr<et2, q2> (. hasB := TRUE; .) ]
|
|
|
- 3760 (. IF braceCls = SymTab.ClSet THEN
|
|
|
- 3761 IF hasB THEN SemError(230) END;
|
|
|
- 3762 lo := SymTab.SetBaseLo(vt);
|
|
|
- 3763 span := SymTab.SetCount(vt);
|
|
|
- 3764 IF (et = SymTab.InvalidType)
|
|
|
- 3765 OR (hasR AND (et2 =
|
|
|
- 3766 SymTab.InvalidType)) THEN
|
|
|
- 3767 ELSE cl :=
|
|
|
- 3768 SymTab.ClassOf(et);
|
|
|
- 3769 IF hasR THEN
|
|
|
- 3770 cl2 :=
|
|
|
- 3771 SymTab.ClassOf(et2)
|
|
|
- 3772 ELSE cl2 := SymTab.ClInt
|
|
|
- 3773 END;
|
|
|
- 3774 IF NOT SymTab.SetElemClassOk(cl)
|
|
|
- 3775 OR (hasR AND NOT
|
|
|
- 3776 SymTab.SetElemClassOk(cl2))
|
|
|
- 3777 THEN
|
|
|
- 3778 SemError(222)
|
|
|
- 3779 ELSIF hasR
|
|
|
- 3780 AND SymTab.ConstInt(qe, v)
|
|
|
- 3781 AND SymTab.ConstInt(q2,
|
|
|
- 3782 v2)
|
|
|
- 3783 AND ((v < lo)
|
|
|
- 3784 OR (v2 < lo)
|
|
|
- 3785 OR (v >= lo +
|
|
|
- 3786 VAL(INTEGER, span))
|
|
|
- 3787 OR (v2 >= lo +
|
|
|
- 3788 VAL(INTEGER, span))
|
|
|
- 3789 OR (v > v2)) THEN
|
|
|
- 3790 SemError(222)
|
|
|
- 3791 ELSIF hasR THEN
|
|
|
- 3792 QbeGen.SetRange(sq, qe, q2,
|
|
|
- 3793 lo, span)
|
|
|
- 3794 ELSIF SymTab.ConstInt(qe,
|
|
|
- 3795 v)
|
|
|
- 3796 AND ((v < lo)
|
|
|
- 3797 OR (v >= lo +
|
|
|
- 3798 VAL(INTEGER,
|
|
|
- 3799 span))) THEN
|
|
|
- 3800 SemError(222)
|
|
|
- 3801 ELSE QbeGen.SetBit(sq, qe,
|
|
|
- 3802 lo, span)
|
|
|
- 3803 END
|
|
|
- 3804 END
|
|
|
- 3805 ELSIF (braceCls = SymTab.ClArray)
|
|
|
- 3806 OR (braceCls =
|
|
|
- 3807 SymTab.ClRecord)
|
|
|
- 3808 OR (braceCls =
|
|
|
- 3809 SymTab.ClClass) THEN
|
|
|
- 3810 IF hasR THEN SemError(230) END;
|
|
|
- 3811 reps := 1;
|
|
|
- 3812 IF hasB THEN
|
|
|
- 3813 IF SymTab.ConstInt(q2, v2)
|
|
|
- 3814 AND (v2 >= 1) THEN
|
|
|
- 3815 reps := v2
|
|
|
- 3816 ELSE SemError(230)
|
|
|
- 3817 END
|
|
|
- 3818 END;
|
|
|
- 3819 k := 0;
|
|
|
- 3820 WHILE k < reps DO
|
|
|
- 3821 QbeGen.CtorElem(qe);
|
|
|
- 3822 INC(k)
|
|
|
- 3823 END
|
|
|
- 3824 END; .)
|
|
|
- 3825 (. (* the BY form repeats the
|
|
|
- 3826 element; keep the AST in
|
|
|
- 3827 step with CtorElem *)
|
|
|
- 3828 k := 0;
|
|
|
- 3829 WHILE k < reps DO
|
|
|
- 3830 AstAppend(AST.NkBlock,
|
|
|
- 3831 node, tail, astEl);
|
|
|
- 3832 INC(k)
|
|
|
- 3833 END; .) .
|
|
|
- 3834 SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal; node: AST.Node> (. VAR et, et2: SymTab.TypeIndex;
|
|
|
- 3835 qe, q2: QbeGen.QVal;
|
|
|
- 3836 v, v2: INTEGER;
|
|
|
- 3837 lo: INTEGER;
|
|
|
- 3838 span: CARDINAL;
|
|
|
- 3839 cl, cl2: INTEGER;
|
|
|
- 3840 hasR: BOOLEAN;
|
|
|
- 3841 astEl: AST.Node; .)
|
|
|
- 3842 = (. hasR := FALSE; .)
|
|
|
- 3843 Expr<et, qe> (. astEl := astCur; .)
|
|
|
- 3844 [ ".." Expr<et2, q2> (. astEl := AST.MakeBin(
|
|
|
- 3845 AST.NkSubrange, 0, astEl, astCur);
|
|
|
- 3846 hasR := TRUE; .) ]
|
|
|
- 3847 (. lo := SymTab.SetBaseLo(st);
|
|
|
- 3848 span := SymTab.SetCount(st);
|
|
|
- 3849 IF (et = SymTab.InvalidType)
|
|
|
- 3850 OR (hasR AND (et2 =
|
|
|
- 3851 SymTab.InvalidType)) THEN
|
|
|
- 3852 ELSE cl :=
|
|
|
- 3853 SymTab.ClassOf(et);
|
|
|
- 3854 IF hasR THEN
|
|
|
- 3855 cl2 :=
|
|
|
- 3856 SymTab.ClassOf(et2)
|
|
|
- 3857 ELSE cl2 := SymTab.ClInt
|
|
|
- 3858 END;
|
|
|
- 3859 IF NOT SymTab.SetElemClassOk(cl)
|
|
|
- 3860 OR (hasR AND NOT
|
|
|
- 3861 SymTab.SetElemClassOk(cl2))
|
|
|
- 3862 THEN
|
|
|
- 3863 SemError(222)
|
|
|
- 3864 ELSIF hasR
|
|
|
- 3865 AND SymTab.ConstInt(qe, v)
|
|
|
- 3866 AND SymTab.ConstInt(q2,
|
|
|
- 3867 v2)
|
|
|
- 3868 AND ((v < lo)
|
|
|
- 3869 OR (v2 < lo)
|
|
|
- 3870 OR (v >= lo +
|
|
|
- 3871 VAL(INTEGER, span))
|
|
|
- 3872 OR (v2 >= lo +
|
|
|
- 3873 VAL(INTEGER, span))
|
|
|
- 3874 OR (v > v2)) THEN
|
|
|
- 3875 SemError(222)
|
|
|
- 3876 ELSIF hasR THEN
|
|
|
- 3877 QbeGen.SetRange(sq, qe, q2,
|
|
|
- 3878 lo, span)
|
|
|
- 3879 ELSIF SymTab.ConstInt(qe,
|
|
|
- 3880 v)
|
|
|
- 3881 AND ((v < lo)
|
|
|
- 3882 OR (v >= lo +
|
|
|
- 3883 VAL(INTEGER,
|
|
|
- 3884 span))) THEN
|
|
|
- 3885 SemError(222)
|
|
|
- 3886 ELSE QbeGen.SetBit(sq, qe,
|
|
|
- 3887 lo, span)
|
|
|
- 3888 END
|
|
|
- 3889 END; .)
|
|
|
- 3890 (. AST.SetChild(node,
|
|
|
- 3891 AST.NChild(node), astEl); .) .
|
|
|
- 3892 GetIdent<VAR n: SymTab.Name>
|
|
|
- 3893 = ident (. LexName(n); .) .
|
|
|
- 3894
|
|
|
- 3895 END M2.
|
|
|
+ 502 SemError(201) END;
|
|
|
+ 503 Lower.NoteCProc(n)
|
|
|
+ 504 ELSIF SymTab.ModKnown(mod)
|
|
|
+ 505 AND NOT SymTab.ImportFrom(mod, n) THEN
|
|
|
+ 506 SemError(201) END; .)
|
|
|
+ 507 | ( "TSIZE" | "SIZE" | "ADR" | "HIGH" | "LEN"
|
|
|
+ 508 | "CHR" | "ORD" | "ORDL" | "VAL" | "ABS" | "CAP"
|
|
|
+ 509 | "UCHR" | "CHR8" | "UORD"
|
|
|
+ 510 | "INC" | "DEC" ) .
|
|
|
+ 511 ImpModList<node: AST.Node> (. VAR n: SymTab.Name; .)
|
|
|
+ 512 = GetIdent<n> (. AST.SetChild(node, AST.NChild(node),
|
|
|
+ 513 AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
+ 514 { "," GetIdent<n> (. AST.SetChild(node, AST.NChild(node),
|
|
|
+ 515 AST.MakeLeaf(AST.NkIdent, n)); .) } .
|
|
|
+ 516 (* Opaque TYPE declarations (definition modules). The targetless
|
|
|
+ 517 alias resolves to InvalidType until step 4 completes it. *)
|
|
|
+ 518 (* Scalar-phase TYPEs: named types, integer subranges, enumerations.
|
|
|
+ 519 Opaque "TYPE T;" needs isDef (definition units); elsewhere 231.
|
|
|
+ 520 Composite forms (ARRAY/RECORD/SET/POINTER) arrive with step 3. *)
|
|
|
+ 521 TypeBlock<isDef: BOOLEAN> (. VAR astSeq, astTail: AST.Node; .)
|
|
|
+ 522 = "TYPE" (. SymTab.BeginTypeBlock;
|
|
|
+ 523 astSeq := AST.NoNode;
|
|
|
+ 524 astTail := AST.NoNode; .)
|
|
|
+ 525 { (. astDecl := AST.NoNode; .)
|
|
|
+ 526 ( TypeItem<isDef> ";" | ClassItem ";" )
|
|
|
+ 527 (. AstAppend(AST.NkDeclSeq,
|
|
|
+ 528 astSeq, astTail, astDecl); .) }
|
|
|
+ 529 (. SymTab.EndTypeBlock;
|
|
|
+ 530 astDecl := astSeq; .) .
|
|
|
+ 531 TypeItem<isDef: BOOLEAN> (. VAR n: SymTab.Name;
|
|
|
+ 532 t, op: SymTab.TypeIndex;
|
|
|
+ 533 astNode: AST.Node; .)
|
|
|
+ 534 = GetIdent<n> (. op := SymTab.OpaqueBase(n);
|
|
|
+ 535 IF op = SymTab.InvalidType THEN
|
|
|
+ 536 IF NOT SymTab.Enter(n,
|
|
|
+ 537 SymTab.KindType) THEN
|
|
|
+ 538 SemError(200) END
|
|
|
+ 539 END; .)
|
|
|
+ 540 ( "=" Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkTypeDecl);
|
|
|
+ 541 AST.SetChild(astNode, 0,
|
|
|
+ 542 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
+ 543 AST.SetTy(astNode, t);
|
|
|
+ 544 astDecl := astNode;
|
|
|
+ 545 IF op # SymTab.InvalidType THEN
|
|
|
+ 546 SymTab.SetTarget(op, t)
|
|
|
+ 547 ELSE SymTab.SetSymType(n, t)
|
|
|
+ 548 END; .)
|
|
|
+ 549 | (. IF op # SymTab.InvalidType THEN
|
|
|
+ 550 (* stays opaque *)
|
|
|
+ 551 ELSIF NOT isDef THEN
|
|
|
+ 552 SemError(231)
|
|
|
+ 553 ELSE SymTab.SetSymType(n,
|
|
|
+ 554 SymTab.NewAlias()) END; .) ) .
|
|
|
+ 555 Type<VAR t: SymTab.TypeIndex; allowOpen: BOOLEAN>
|
|
|
+ 556 = TypeIdent<t> [ Subrange<t> ] (* anchored subrange: T[lo..hi] *)
|
|
|
+ 557 | Subrange<t>
|
|
|
+ 558 | Enum<t>
|
|
|
+ 559 | ArrayType<t, allowOpen>
|
|
|
+ 560 | SetType<t>
|
|
|
+ 561 | RecordType<t>
|
|
|
+ 562 | PointerType<t>
|
|
|
+ 563 | ProcType<t> .
|
|
|
+ 564 PointerType<VAR t: SymTab.TypeIndex> (. VAR base: SymTab.TypeIndex; .)
|
|
|
+ 565 = "POINTER" "TO" Type<base, FALSE>(. t := SymTab.NewPtr(base); .) .
|
|
|
+ 566 (* Procedure types (step 8.5): PROCEDURE (params): result. Values
|
|
|
+ 567 are code pointers; params are collected into the descriptor. *)
|
|
|
+ 568 ProcType<VAR t: SymTab.TypeIndex> (. VAR res, pt: SymTab.TypeIndex;
|
|
|
+ 569 isV: BOOLEAN; .)
|
|
|
+ 570 = "PROCEDURE" (. res := SymTab.InvalidType;
|
|
|
+ 571 t := SymTab.NewProcType(res); .)
|
|
|
+ 572 [ "(" [ ProcTypeSection<t> { ";" ProcTypeSection<t> } ] ")" ]
|
|
|
+ 573 [ ":" TypeIdent<res> (. SymTab.SetProcTypeRes(t, res); .) ] .
|
|
|
+ 574 ProcTypeSection<t: SymTab.TypeIndex> (. VAR pt: SymTab.TypeIndex;
|
|
|
+ 575 isV: BOOLEAN;
|
|
|
+ 576 cnt, k: CARDINAL;
|
|
|
+ 577 names: ARRAY [0 .. 15] OF SymTab.Name; .)
|
|
|
+ 578 = (. isV := FALSE; cnt := 0; .)
|
|
|
+ 579 [ "VAR" (. isV := TRUE; .) ]
|
|
|
+ 580 ( GetIdent<names[cnt]> (. INC(cnt); .)
|
|
|
+ 581 { "," GetIdent<names[cnt]> (. INC(cnt); .) }
|
|
|
+ 582 ( ":" Type<pt, TRUE> (. k := 0;
|
|
|
+ 583 WHILE k < cnt DO
|
|
|
+ 584 SymTab.ProcTypeAdd(t, isV, pt);
|
|
|
+ 585 INC(k)
|
|
|
+ 586 END; .)
|
|
|
+ 587 | (. (* type-only parameter list:
|
|
|
+ 588 each name is a type (GNU
|
|
|
+ 589 shorthand used by the
|
|
|
+ 590 Coco/R scanner frame) *)
|
|
|
+ 591 k := 0;
|
|
|
+ 592 WHILE k < cnt DO
|
|
|
+ 593 IF SymTab.Lookup(names[k])
|
|
|
+ 594 AND ((SymTab.SymKind(names[k]) = SymTab.KindType)
|
|
|
+ 595 OR (SymTab.SymKind(names[k]) = SymTab.KindPredef)) THEN
|
|
|
+ 596 pt := SymTab.SymType(names[k])
|
|
|
+ 597 ELSE SemError(201);
|
|
|
+ 598 pt := SymTab.InvalidType
|
|
|
+ 599 END;
|
|
|
+ 600 SymTab.ProcTypeAdd(t, isV, pt);
|
|
|
+ 601 INC(k)
|
|
|
+ 602 END; .) )
|
|
|
+ 603 | Type<pt, TRUE> (. (* unnamed parameter (PIM):
|
|
|
+ 604 e.g. PROCEDURE (VAR ARRAY OF REAL) *)
|
|
|
+ 605 SymTab.ProcTypeAdd(t, isV, pt); .) ) .
|
|
|
+ 606 (* Arrays: "OF" without bounds is an open formal (allowed only
|
|
|
+ 607 where allowOpen); "[lo..hi, ...]" nests bounded levels inside
|
|
|
+ 608 out. Bounds are folded literals (int/char); anything else 230.
|
|
|
+ 609 Bare-type indices ("ARRAY Color OF") wait for enum ordinals. *)
|
|
|
+ 610 ArrayType<VAR t: SymTab.TypeIndex; allowOpen: BOOLEAN>
|
|
|
+ 611 (. VAR elem: SymTab.TypeIndex;
|
|
|
+ 612 ok: BOOLEAN;
|
|
|
+ 613 bnds, bndh: ARRAY [0 .. 7] OF INTEGER;
|
|
|
+ 614 nb, k: CARDINAL;
|
|
|
+ 615 idx: SymTab.TypeIndex;
|
|
|
+ 616 ilo, ihi: INTEGER; .)
|
|
|
+ 617 = "ARRAY"
|
|
|
+ 618 ( "OF" Type<elem, FALSE> (. IF NOT allowOpen THEN
|
|
|
+ 619 SemError(230) END;
|
|
|
+ 620 t := SymTab.NewOpenArray(elem); .)
|
|
|
+ 621 | TypeIdent<idx> [ Subrange<idx> ]
|
|
|
+ 622 "OF" Type<elem, FALSE> (. (* index-type array: the index
|
|
|
+ 623 type's ordinal bounds give the
|
|
|
+ 624 [lo..hi] pair *)
|
|
|
+ 625 IF SymTab.TypeBounds(idx, ilo,
|
|
|
+ 626 ihi)
|
|
|
+ 627 THEN t := SymTab.NewArrayB(elem,
|
|
|
+ 628 ilo, ihi)
|
|
|
+ 629 ELSE SemError(230);
|
|
|
+ 630 t := SymTab.InvalidType
|
|
|
+ 631 END; .)
|
|
|
+ 632 | "[" (. SymTab.BoundBegin; ok := TRUE; .)
|
|
|
+ 633 BoundPair<ok>
|
|
|
+ 634 { "," BoundPair<ok> }
|
|
|
+ 635 "]" (. (* snapshot before the element
|
|
|
+ 636 type, which reuses the bound
|
|
|
+ 637 buffer for a nested ARRAY *)
|
|
|
+ 638 nb := SymTab.BoundCount();
|
|
|
+ 639 k := 0;
|
|
|
+ 640 WHILE k < nb DO
|
|
|
+ 641 bnds[k] := SymTab.BoundLo(k);
|
|
|
+ 642 bndh[k] := SymTab.BoundHi(k);
|
|
|
+ 643 INC(k)
|
|
|
+ 644 END; .)
|
|
|
+ 645 "OF" Type<elem, FALSE>
|
|
|
+ 646 (. IF ok THEN
|
|
|
+ 647 k := nb;
|
|
|
+ 648 WHILE k > 0 DO
|
|
|
+ 649 DEC(k);
|
|
|
+ 650 elem := SymTab.NewArrayB(
|
|
|
+ 651 elem, bnds[k], bndh[k])
|
|
|
+ 652 END;
|
|
|
+ 653 t := elem
|
|
|
+ 654 ELSE t := SymTab.InvalidType
|
|
|
+ 655 END; .) ) .
|
|
|
+ 656 BoundPair<VAR ok: BOOLEAN> (. VAR tlo, thi: SymTab.TypeIndex;
|
|
|
+ 657 qlo, qhi: QbeGen.QVal;
|
|
|
+ 658 lo, hi: INTEGER;
|
|
|
+ 659 cl, cl2: INTEGER; .)
|
|
|
+ 660 = Expr<tlo, qlo> ".." Expr<thi, qhi>
|
|
|
+ 661 (. IF (tlo = SymTab.InvalidType)
|
|
|
+ 662 OR (thi = SymTab.InvalidType) THEN
|
|
|
+ 663 ok := FALSE
|
|
|
+ 664 ELSE cl := SymTab.ClassOf(tlo);
|
|
|
+ 665 cl2 := SymTab.ClassOf(thi);
|
|
|
+ 666 IF ((cl # SymTab.ClInt)
|
|
|
+ 667 AND (cl # SymTab.ClChar))
|
|
|
+ 668 OR ((cl2 # SymTab.ClInt)
|
|
|
+ 669 AND (cl2 # SymTab.ClChar)) THEN
|
|
|
+ 670 SemError(230); ok := FALSE
|
|
|
+ 671 ELSIF NOT SymTab.ConstInt(qlo, lo)
|
|
|
+ 672 OR NOT SymTab.ConstInt(qhi, hi)
|
|
|
+ 673 OR (lo > hi) THEN
|
|
|
+ 674 SemError(230); ok := FALSE
|
|
|
+ 675 ELSIF NOT SymTab.BoundAdd(lo, hi) THEN
|
|
|
+ 676 SemError(230); ok := FALSE
|
|
|
+ 677 END;
|
|
|
+ 678 END; .) .
|
|
|
+ 679 (* Sets: multi-word masks over bases ≤ 256 values (bool, char,
|
|
|
+ 680 bounded subranges; enums wait for ordinals, INTEGER is
|
|
|
+ 681 unbounded). Literals are SET OF [0..255]; assignment and
|
|
|
+ 682 comparison across suitable bases are lenient (masks over min
|
|
|
+ 683 words + zero-check extras), out-of-span literals are 222. *)
|
|
|
+ 684 SetType<VAR t: SymTab.TypeIndex> (. VAR base: SymTab.TypeIndex;
|
|
|
+ 685 blo, bhi, bspan: INTEGER;
|
|
|
+ 686 bcls: INTEGER; .)
|
|
|
+ 687 = "SET" "OF" Type<base, FALSE>
|
|
|
+ 688 (. IF base = SymTab.InvalidType THEN
|
|
|
+ 689 t := SymTab.InvalidType
|
|
|
+ 690 ELSE bcls :=
|
|
|
+ 691 SymTab.ClassOf(base);
|
|
|
+ 692 IF bcls = SymTab.ClBool THEN
|
|
|
+ 693 blo := 0; bspan := 2
|
|
|
+ 694 ELSIF bcls = SymTab.ClChar THEN
|
|
|
+ 695 blo := 0; bspan := 256
|
|
|
+ 696 ELSIF bcls = SymTab.ClEnum THEN
|
|
|
+ 697 blo := 0;
|
|
|
+ 698 bspan := VAL(INTEGER,
|
|
|
+ 699 SymTab.EnumCount(base))
|
|
|
+ 700 ELSIF SymTab.SubBounds(base,
|
|
|
+ 701 blo, bhi) THEN
|
|
|
+ 702 bspan := bhi - blo + 1
|
|
|
+ 703 ELSE bspan := 0 END;
|
|
|
+ 704 IF (bspan <= 0)
|
|
|
+ 705 OR (bspan > 65536) THEN
|
|
|
+ 706 SemError(230);
|
|
|
+ 707 t := SymTab.InvalidType
|
|
|
+ 708 ELSE t := SymTab.NewSet(base)
|
|
|
+ 709 END
|
|
|
+ 710 END; .) .
|
|
|
+ 711 (* Records: flat blobs; array fields are pointers to static
|
|
|
+ 712 descriptors (locked amendment), nested records inline. Field
|
|
|
+ 713 offsets static and declaration-ordered. *)
|
|
|
+ 714 (* Field list: plain fields and (optionally) one variant part. The
|
|
|
+ 715 variant part is a `CASE ... END` item; because it starts with the
|
|
|
+ 716 CASE keyword it is unambiguously distinguishable from a field
|
|
|
+ 717 (which starts with an identifier). *)
|
|
|
+ 718 RecordType<VAR t: SymTab.TypeIndex> (. VAR t2: SymTab.TypeIndex;
|
|
|
+ 719 tagOk: BOOLEAN; .)
|
|
|
+ 720 = "RECORD" (. t := SymTab.NewRecord(); .)
|
|
|
+ 721 [ RecItem<t> { ";" [ RecItem<t> ] } ]
|
|
|
+ 722 "END" .
|
|
|
+ 723 RecItem<rec: SymTab.TypeIndex> (. VAR tt: SymTab.TypeIndex; .)
|
|
|
+ 724 = RecField<rec>
|
|
|
+ 725 | CaseField<rec> (. SymTab.MarkVariant(rec); .) .
|
|
|
+ 726 (* A variant part: CASE tag : Type OF variants. The layout overlays
|
|
|
+ 727 every branch from the tag slot (see SymTab.ComputeOffsets). *)
|
|
|
+ 728 CaseField<rec: SymTab.TypeIndex> (. VAR tagT: SymTab.TypeIndex;
|
|
|
+ 729 tagN: SymTab.Name; .)
|
|
|
+ 730 = "CASE" (. SymTab.ResetFields(rec); .)
|
|
|
+ 731 GetIdent<tagN> (. IF NOT SymTab.FieldPending(rec,
|
|
|
+ 732 tagN) THEN
|
|
|
+ 733 SemError(200) END; .)
|
|
|
+ 734 ":" Type<tagT, FALSE> (. IF (tagT # SymTab.InvalidType)
|
|
|
+ 735 AND NOT SymTab.IsOrdinal(tagT) THEN
|
|
|
+ 736 SemError(224)
|
|
|
+ 737 END;
|
|
|
+ 738 SymTab.FixPendingF(rec, tagT);
|
|
|
+ 739 SymTab.SetVariantTag(rec, tagN); .)
|
|
|
+ 740 "OF"
|
|
|
+ 741 RecFieldList<rec>
|
|
|
+ 742 { "|" (. SymTab.ResetFields(rec); .)
|
|
|
+ 743 RecFieldList<rec> }
|
|
|
+ 744 "END" .
|
|
|
+ 745 RecFieldList<rec: SymTab.TypeIndex> (. VAR lt, lq: SymTab.TypeIndex;
|
|
|
+ 746 lv1, lv2: QbeGen.QVal; .)
|
|
|
+ 747 = VarLabel<lt, lv1> [ ".." VarLabel<lq, lv2> ] ":"
|
|
|
+ 748 RecField<rec> { ";" [ RecField<rec> ] } .
|
|
|
+ 749 (* Variant case label: a constant (or a constant range). Values are
|
|
|
+ 750 not interpreted (the layout overlays regardless). *)
|
|
|
+ 751 VarLabel<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 752 (. VAR lname: SymTab.Name; .)
|
|
|
+ 753 = ( ident (. LexName(lname);
|
|
|
+ 754 QbeGen.CopyOp("0", q);
|
|
|
+ 755 t := SymTab.IntType(); .)
|
|
|
+ 756 | integer (. LexString(lname);
|
|
|
+ 757 QbeGen.CopyOp("0", q);
|
|
|
+ 758 t := SymTab.IntType(); .)
|
|
|
+ 759 | charConst (. LexString(lname);
|
|
|
+ 760 QbeGen.CopyOp("0", q);
|
|
|
+ 761 t := SymTab.CharType(); .) ) .
|
|
|
+ 762 RecField<rec: SymTab.TypeIndex> (. VAR n: SymTab.Name;
|
|
|
+ 763 t2: SymTab.TypeIndex; .)
|
|
|
+ 764 = RecIdents<rec> ":" Type<t2, FALSE>(. SymTab.FixPendingF(rec, t2); .) .
|
|
|
+ 765 RecIdents<rec: SymTab.TypeIndex> (. VAR n: SymTab.Name; .)
|
|
|
+ 766 = GetIdent<n> (. IF NOT SymTab.FieldPending(rec,
|
|
|
+ 767 n) THEN
|
|
|
+ 768 SemError(200) END; .)
|
|
|
+ 769 { "," GetIdent<n> (. IF NOT SymTab.FieldPending(rec,
|
|
|
+ 770 n) THEN
|
|
|
+ 771 SemError(200) END; .) } .
|
|
|
+ 772 TypeIdent<VAR t: SymTab.TypeIndex> (. VAR n, qid: SymTab.Name;
|
|
|
+ 773 k: INTEGER;
|
|
|
+ 774 dotted: BOOLEAN; .)
|
|
|
+ 775 = GetIdent<n> (. dotted := FALSE;
|
|
|
+ 776 IF NOT SymTab.Lookup(n) THEN
|
|
|
+ 777 k := -1;
|
|
|
+ 778 t := SymTab.ForwardType(n);
|
|
|
+ 779 IF t = SymTab.InvalidType THEN
|
|
|
+ 780 SemError(201)
|
|
|
+ 781 END
|
|
|
+ 782 ELSE k := SymTab.SymKind(n);
|
|
|
+ 783 IF (k = SymTab.KindType)
|
|
|
+ 784 OR (k = SymTab.KindPredef) THEN
|
|
|
+ 785 t := SymTab.SymType(n)
|
|
|
+ 786 ELSE t := SymTab.InvalidType
|
|
|
+ 787 END
|
|
|
+ 788 END; .)
|
|
|
+ 789 [ "." GetIdent<qid> (. dotted := TRUE;
|
|
|
+ 790 IF k = SymTab.KindModule THEN
|
|
|
+ 791 t := SymTab.QualType(n, qid);
|
|
|
+ 792 IF t = SymTab.InvalidType THEN
|
|
|
+ 793 SemError(201)
|
|
|
+ 794 END
|
|
|
+ 795 ELSE SemError(221);
|
|
|
+ 796 t := SymTab.InvalidType
|
|
|
+ 797 END; .) ]
|
|
|
+ 798 (. IF NOT dotted THEN
|
|
|
+ 799 IF (k = SymTab.KindModule)
|
|
|
+ 800 OR ((k # SymTab.KindType)
|
|
|
+ 801 AND (k # SymTab.KindPredef)
|
|
|
+ 802 AND (k # SymTab.KindImport)
|
|
|
+ 803 AND (k # -1)) THEN
|
|
|
+ 804 SemError(221)
|
|
|
+ 805 END
|
|
|
+ 806 END; .) .
|
|
|
+ 807 Subrange<VAR t: SymTab.TypeIndex> (. VAR tlo, thi: SymTab.TypeIndex;
|
|
|
+ 808 qlo, qhi: QbeGen.QVal;
|
|
|
+ 809 lo, hi: INTEGER; .)
|
|
|
+ 810 = "[" Expr<tlo, qlo> ".." Expr<thi, qhi>
|
|
|
+ 811 (. IF (tlo = SymTab.InvalidType)
|
|
|
+ 812 OR (thi = SymTab.InvalidType) THEN
|
|
|
+ 813 t := SymTab.InvalidType
|
|
|
+ 814 ELSIF NOT SymTab.IsOrdinal(tlo)
|
|
|
+ 815 OR NOT SymTab.IsOrdinal(thi) THEN
|
|
|
+ 816 SemError(230);
|
|
|
+ 817 t := SymTab.InvalidType
|
|
|
+ 818 ELSIF NOT SymTab.ConstInt(qlo, lo)
|
|
|
+ 819 OR NOT SymTab.ConstInt(qhi, hi)
|
|
|
+ 820 OR (lo > hi) THEN
|
|
|
+ 821 SemError(230);
|
|
|
+ 822 t := SymTab.InvalidType
|
|
|
+ 823 ELSE t := SymTab.NewSubR(lo, hi)
|
|
|
+ 824 END; .)
|
|
|
+ 825 "]" .
|
|
|
+ 826 Enum<VAR t: SymTab.TypeIndex> (. VAR n: SymTab.Name;
|
|
|
+ 827 ord: INTEGER;
|
|
|
+ 828 qv: QbeGen.QVal; .)
|
|
|
+ 829 = "(" (. t := SymTab.NewEnum();
|
|
|
+ 830 ord := 0; .)
|
|
|
+ 831 GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
+ 832 SymTab.KindConst) THEN
|
|
|
+ 833 SemError(200) END;
|
|
|
+ 834 SymTab.SetSymType(n, t);
|
|
|
+ 835 QbeGen.IntStr(ord, qv);
|
|
|
+ 836 SymTab.SetSymVal(n, qv);
|
|
|
+ 837 Lower.NoteVar(n,
|
|
|
+ 838 SymTab.KindConst, t);
|
|
|
+ 839 Lower.NoteConstVal(qv);
|
|
|
+ 840 INC(ord); .)
|
|
|
+ 841 { "," GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
+ 842 SymTab.KindConst) THEN
|
|
|
+ 843 SemError(200) END;
|
|
|
+ 844 SymTab.SetSymType(n, t);
|
|
|
+ 845 QbeGen.IntStr(ord, qv);
|
|
|
+ 846 SymTab.SetSymVal(n, qv);
|
|
|
+ 847 Lower.NoteVar(n,
|
|
|
+ 848 SymTab.KindConst, t);
|
|
|
+ 849 Lower.NoteConstVal(qv);
|
|
|
+ 850 INC(ord); .) }
|
|
|
+ 851 ")" (. SymTab.SetEnumCount(t,
|
|
|
+ 852 VAL(CARDINAL, ord)); .) .
|
|
|
+ 853 (* Clarion-form classes (docs/OOP.txt): declaration + single
|
|
|
+ 854 inheritance + IMPLEMENTATION blocks. Scopes and member checks
|
|
|
+ 855 now; lowering (vtable, dispatch, THIS) later — one 230 per
|
|
|
+ 856 class/impl block. Methods end with ";" per the Table example
|
|
|
+ 857 (not "," as in the sketch). No underscores in identifiers. *)
|
|
|
+ 858 (* Single CLASS item in both loops: separating declaration from
|
|
|
+ 859 IMPLEMENTATION at the loop level needs 2-token lookahead
|
|
|
+ 860 (CLASS ident vs CLASS IMPLEMENTATION), which LL(1) cannot do.
|
|
|
+ 861 The second token decides after CLASS is consumed. A misplaced
|
|
|
+ 862 CLASS IMPLEMENTATION inside TYPE still parses (harmless: the
|
|
|
+ 863 whole unit ends 230 until lowering). *)
|
|
|
+ 864 ClassItem
|
|
|
+ 865 = "CLASS" ( "IMPLEMENTATION" ClassImplRest | ClassRest ) .
|
|
|
+ 866 ClassRest (. VAR cn, m2, pn: SymTab.Name;
|
|
|
+ 867 ct: SymTab.TypeIndex; .)
|
|
|
+ 868 = GetIdent<cn> (. IF NOT SymTab.Enter(cn,
|
|
|
+ 869 SymTab.KindType) THEN
|
|
|
+ 870 SemError(200) END;
|
|
|
+ 871 ct := SymTab.NewClass();
|
|
|
+ 872 SymTab.SetSymType(cn, ct);
|
|
|
+ 873 SymTab.PushClassScope(ct);
|
|
|
+ 874 astCls := AST.MakeNode(AST.NkClassDecl);
|
|
|
+ 875 AST.SetChild(astCls, 0,
|
|
|
+ 876 AST.MakeLeaf(AST.NkIdent, cn));
|
|
|
+ 877 astClsP := AST.NoNode;
|
|
|
+ 878 astClsPTail := AST.NoNode;
|
|
|
+ 879 astClsF := AST.NoNode;
|
|
|
+ 880 astClsFTail := AST.NoNode;
|
|
|
+ 881 astClsM := AST.NoNode;
|
|
|
+ 882 astClsMTail := AST.NoNode; .)
|
|
|
+ 883 [ Parents<ct> ]
|
|
|
+ 884 ";"
|
|
|
+ 885 { ClassField<ct> ";" }
|
|
|
+ 886 { MethodHeading<pn, SymTab.InvalidType> ";"
|
|
|
+ 887 (. Lower.ScopeLeave;
|
|
|
+ 888 SymTab.CloseProc;
|
|
|
+ 889 QbeGen.AbortFunc; .) }
|
|
|
+ 890 "END"
|
|
|
+ 891 GetIdent<m2> (. IF NOT SymTab.Equal(cn, m2) THEN
|
|
|
+ 892 SemError(202) END;
|
|
|
+ 893 SymTab.LayoutClass(ct);
|
|
|
+ 894 SymTab.PopScope;
|
|
|
+ 895 AST.SetChild(astCls, 1, astClsP);
|
|
|
+ 896 AST.SetChild(astCls, 2, astClsF);
|
|
|
+ 897 AST.SetChild(astCls, 3, astClsM);
|
|
|
+ 898 astDecl := astCls; .) .
|
|
|
+ 899 Parents<ct: SymTab.TypeIndex> (. VAR p: SymTab.Name; .)
|
|
|
+ 900 = "(" Parent1<ct>
|
|
|
+ 901 { "," GetIdent<p> (. SemError(230); .) }
|
|
|
+ 902 ")" .
|
|
|
+ 903 Parent1<ct: SymTab.TypeIndex> (. VAR p: SymTab.Name;
|
|
|
+ 904 pt: SymTab.TypeIndex; .)
|
|
|
+ 905 = GetIdent<p> (. IF NOT SymTab.Lookup(p) THEN
|
|
|
+ 906 SemError(201)
|
|
|
+ 907 ELSE pt := SymTab.SymType(p);
|
|
|
+ 908 IF SymTab.ClassOf(pt) #
|
|
|
+ 909 SymTab.ClClass THEN
|
|
|
+ 910 SemError(230)
|
|
|
+ 911 ELSE SymTab.SetParent(ct, pt)
|
|
|
+ 912 END
|
|
|
+ 913 END;
|
|
|
+ 914 AstAppend(AST.NkFieldDecl,
|
|
|
+ 915 astClsP, astClsPTail,
|
|
|
+ 916 AST.MakeLeaf(AST.NkIdent, p)); .) .
|
|
|
+ 917 ClassField<ct: SymTab.TypeIndex> (. VAR n, rhs: SymTab.Name;
|
|
|
+ 918 t: SymTab.TypeIndex;
|
|
|
+ 919 astNode: AST.Node; .)
|
|
|
+ 920 = GetIdent<n>
|
|
|
+ 921 ( "=" GetIdent<rhs> (. IF NOT SymTab.Enter(n,
|
|
|
+ 922 SymTab.KindConst) THEN
|
|
|
+ 923 SemError(200) END;
|
|
|
+ 924 astNode := AST.MakeNode(AST.NkConstDecl);
|
|
|
+ 925 AST.SetChild(astNode, 0,
|
|
|
+ 926 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
+ 927 AST.SetChild(astNode, 1,
|
|
|
+ 928 AST.MakeLeaf(AST.NkIdent, rhs));
|
|
|
+ 929 AstAppend(AST.NkFieldDecl,
|
|
|
+ 930 astClsF, astClsFTail, astNode);
|
|
|
+ 931 IF SymTab.Lookup(rhs) THEN
|
|
|
+ 932 SymTab.SetSymType(n,
|
|
|
+ 933 SymTab.SymType(rhs))
|
|
|
+ 934 END; .)
|
|
|
+ 935 | (. IF NOT SymTab.FieldPending(ct,
|
|
|
+ 936 n) THEN
|
|
|
+ 937 SemError(200) END;
|
|
|
+ 938 astNode := AST.MakeNode(AST.NkVarDecl);
|
|
|
+ 939 AST.SetChild(astNode, 0,
|
|
|
+ 940 AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
+ 941 { "," GetIdent<n> (. IF NOT SymTab.FieldPending(ct,
|
|
|
+ 942 n) THEN
|
|
|
+ 943 SemError(200) END;
|
|
|
+ 944 AST.SetChild(astNode,
|
|
|
+ 945 AST.NChild(astNode),
|
|
|
+ 946 AST.MakeLeaf(AST.NkIdent, n)); .) }
|
|
|
+ 947 ":" Type<t, FALSE> (. SymTab.FixPendingF(ct, t);
|
|
|
+ 948 AST.SetTy(astNode, t);
|
|
|
+ 949 AstAppend(AST.NkFieldDecl,
|
|
|
+ 950 astClsF, astClsFTail, astNode); .) ) .
|
|
|
+ 951 MethodHeading<VAR pn: SymTab.Name; ct: SymTab.TypeIndex>
|
|
|
+ 952 (. VAR wantVirt: BOOLEAN; .)
|
|
|
+ 953 = (. wantVirt := FALSE; .)
|
|
|
+ 954 [ "VIRTUAL" (. wantVirt := TRUE; .) ]
|
|
|
+ 955 ProcHeading<pn, ct> (. IF wantVirt THEN
|
|
|
+ 956 SymTab.MarkVirtual END;
|
|
|
+ 957 astMethod := AST.MakeNode(AST.NkProcDecl);
|
|
|
+ 958 AST.SetChild(astMethod, 0,
|
|
|
+ 959 AST.MakeLeaf(AST.NkIdent, pn));
|
|
|
+ 960 IF wantVirt THEN
|
|
|
+ 961 AST.SetOp(astMethod, 3)
|
|
|
+ 962 ELSE AST.SetOp(astMethod, 0)
|
|
|
+ 963 END;
|
|
|
+ 964 AstAppend(AST.NkFieldDecl,
|
|
|
+ 965 astClsM, astClsMTail, astMethod); .) .
|
|
|
+ 966 ClassImplRest (. VAR cn, m2: SymTab.Name;
|
|
|
+ 967 ct: SymTab.TypeIndex; .)
|
|
|
+ 968 = GetIdent<cn> (. IF NOT SymTab.Lookup(cn) THEN
|
|
|
+ 969 SemError(201);
|
|
|
+ 970 ct := SymTab.InvalidType
|
|
|
+ 971 ELSE ct := SymTab.SymType(cn);
|
|
|
+ 972 IF SymTab.ClassOf(ct) #
|
|
|
+ 973 SymTab.ClClass THEN
|
|
|
+ 974 SemError(230);
|
|
|
+ 975 ct := SymTab.InvalidType
|
|
|
+ 976 END
|
|
|
+ 977 END;
|
|
|
+ 978 astCls := AST.MakeNode(AST.NkClassDecl);
|
|
|
+ 979 AST.SetOp(astCls, 1);
|
|
|
+ 980 AST.SetChild(astCls, 0,
|
|
|
+ 981 AST.MakeLeaf(AST.NkIdent, cn));
|
|
|
+ 982 astClsM := AST.NoNode;
|
|
|
+ 983 astClsMTail := AST.NoNode;
|
|
|
+ 984 astStmt := AST.NoNode;
|
|
|
+ 985 IF ct #
|
|
|
+ 986 SymTab.InvalidType THEN
|
|
|
+ 987 IF NOT SymTab.PushClassMembers(
|
|
|
+ 988 ct) THEN
|
|
|
+ 989 SemError(230) END;
|
|
|
+ 990 SymTab.PushImplClass(ct)
|
|
|
+ 991 END; .)
|
|
|
+ 992 ";" { MethodImpl<ct> ";" }
|
|
|
+ 993 (. astStmt := AST.NoNode; .)
|
|
|
+ 994 [ "BEGIN" (. astStmt := AST.MakeNode(AST.NkBlock);
|
|
|
+ 995 QbeGen.BeginInit(cn); .)
|
|
|
+ 996 [ StatSeq ] (. QbeGen.EndInit; .) ]
|
|
|
+ 997 "END"
|
|
|
+ 998 GetIdent<m2> (. IF NOT SymTab.Equal(cn, m2) THEN
|
|
|
+ 999 SemError(202) END;
|
|
|
+ 1000 SymTab.PopImplClass;
|
|
|
+ 1001 SymTab.PopScope;
|
|
|
+ 1002 AST.SetChild(astCls, 1, AST.NoNode);
|
|
|
+ 1003 AST.SetChild(astCls, 2, astStmt);
|
|
|
+ 1004 AST.SetChild(astCls, 3, astClsM);
|
|
|
+ 1005 astDecl := astCls; .) .
|
|
|
+ 1006 MethodImpl<ct: SymTab.TypeIndex> (. VAR pn: SymTab.Name;
|
|
|
+ 1007 thisQ: QbeGen.QVal;
|
|
|
+ 1008 methRes: SymTab.TypeIndex; .)
|
|
|
+ 1009 = MethodHeading<pn, ct> ";"
|
|
|
+ 1010 (. IF (ct #
|
|
|
+ 1011 SymTab.InvalidType)
|
|
|
+ 1012 AND NOT SymTab.MethodExists(ct,
|
|
|
+ 1013 pn) THEN
|
|
|
+ 1014 SemError(201) END; .)
|
|
|
+ 1015 ( "FORWARD" (. AST.SetOp(astMethod, 1);
|
|
|
+ 1016 SymTab.MarkFwd;
|
|
|
+ 1017 QbeGen.AbortFunc;
|
|
|
+ 1018 Lower.ScopeLeave;
|
|
|
+ 1019 SymTab.CloseProc; .)
|
|
|
+ 1020 | (. QbeGen.EndFuncHeader;
|
|
|
+ 1021 (* bind the receiver: bare
|
|
|
+ 1022 field names resolve
|
|
|
+ 1023 against THIS *)
|
|
|
+ 1024 QbeGen.ThisBase(thisQ);
|
|
|
+ 1025 QbeGen.PushWith(thisQ); .)
|
|
|
+ 1026 Block<pn> (. AST.SetChild(astMethod, 1, astStmt);
|
|
|
+ 1027 QbeGen.PopWith;
|
|
|
+ 1028 methRes := SymTab.CurRes();
|
|
|
+ 1029 Lower.ScopeLeave;
|
|
|
+ 1030 SymTab.CloseProc;
|
|
|
+ 1031 QbeGen.EndFunc(methRes); .) ) .
|
|
|
+ 1032 ConstBlock (. VAR astSeq, astTail: AST.Node; .)
|
|
|
+ 1033 = "CONST" (. astSeq := AST.NoNode;
|
|
|
+ 1034 astTail := AST.NoNode; .)
|
|
|
+ 1035 { ConstDecl ";" (. AstAppend(AST.NkDeclSeq,
|
|
|
+ 1036 astSeq, astTail, astDecl); .) }
|
|
|
+ 1037 (. astDecl := astSeq; .) .
|
|
|
+ 1038 ConstDecl (. VAR n: SymTab.Name;
|
|
|
+ 1039 t: SymTab.TypeIndex;
|
|
|
+ 1040 qv: QbeGen.QVal;
|
|
|
+ 1041 cls: INTEGER;
|
|
|
+ 1042 astNode: AST.Node; .)
|
|
|
+ 1043 = GetIdent<n> (. IF NOT SymTab.Enter(n,
|
|
|
+ 1044 SymTab.KindConst) THEN
|
|
|
+ 1045 SemError(200) END; .)
|
|
|
+ 1046 "="
|
|
|
+ 1047 Expr<t, qv> (. astNode := AST.MakeNode(AST.NkConstDecl);
|
|
|
+ 1048 AST.SetChild(astNode, 0,
|
|
|
+ 1049 AST.MakeLeaf(AST.NkIdent, n));
|
|
|
+ 1050 AST.SetChild(astNode, 1, astCur);
|
|
|
+ 1051 AST.SetTy(astNode, t);
|
|
|
+ 1052 astDecl := astNode;
|
|
|
+ 1053 Lower.NoteVar(n, SymTab.KindConst, t);
|
|
|
+ 1054 Lower.NoteConstVal(qv);
|
|
|
+ 1055 SymTab.SetSymType(n, t);
|
|
|
+ 1056 cls := SymTab.ClassOf(t);
|
|
|
+ 1057 IF (cls = SymTab.ClArray)
|
|
|
+ 1058 OR (cls = SymTab.ClRecord)
|
|
|
+ 1059 OR (cls = SymTab.ClClass)
|
|
|
+ 1060 OR (cls = SymTab.ClStr)
|
|
|
+ 1061 OR (cls = SymTab.ClUStr) THEN
|
|
|
+ 1062 (* an aggregate/string
|
|
|
+ 1063 constant: qv is its
|
|
|
+ 1064 descriptor address; no
|
|
|
+ 1065 scalar data *)
|
|
|
+ 1066 SymTab.SetSymVal(n, qv)
|
|
|
+ 1067 ELSIF NOT QbeGen.IsImm(qv) THEN
|
|
|
+ 1068 SemError(230)
|
|
|
+ 1069 ELSE
|
|
|
+ 1070 SymTab.SetSymVal(n, qv);
|
|
|
+ 1071 QbeGen.DeclConst(n, qv, t)
|
|
|
+ 1072 END; .) .
|
|
|
+ 1073 VarBlock (. VAR astSeq, astTail: AST.Node; .)
|
|
|
+ 1074 = "VAR" (. astSeq := AST.NoNode;
|
|
|
+ 1075 astTail := AST.NoNode; .)
|
|
|
+ 1076 { VarDecl ";" (. AstAppend(AST.NkDeclSeq,
|
|
|
+ 1077 astSeq, astTail, astDecl); .) }
|
|
|
+ 1078 (. astDecl := astSeq; .) .
|
|
|
+ 1079 VarDecl (. VAR nm: SymTab.Name;
|
|
|
+ 1080 t: SymTab.TypeIndex;
|
|
|
+ 1081 i: CARDINAL;
|
|
|
+ 1082 cls: INTEGER;
|
|
|
+ 1083 astNode, astTail: AST.Node; .)
|
|
|
+ 1084 = VarIdents ":"
|
|
|
+ 1085 Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkVarDecl);
|
|
|
+ 1086 astTail := astNode;
|
|
|
+ 1087 i := 0;
|
|
|
+ 1088 WHILE i < SymTab.PendCount() DO
|
|
|
+ 1089 SymTab.PendName(i, nm);
|
|
|
+ 1090 Lower.NoteVar(nm, SymTab.KindVar, t);
|
|
|
+ 1091 (* chunked: a VAR list can
|
|
|
+ 1092 exceed AST.MaxChild *)
|
|
|
+ 1093 AstAppend(AST.NkBlock,
|
|
|
+ 1094 astNode, astTail,
|
|
|
+ 1095 AST.MakeLeaf(AST.NkIdent, nm));
|
|
|
+ 1096 INC(i)
|
|
|
+ 1097 END;
|
|
|
+ 1098 AST.SetTy(astNode, t);
|
|
|
+ 1099 astDecl := astNode;
|
|
|
+ 1100 cls := SymTab.ClassOf(t);
|
|
|
+ 1101 IF (t # SymTab.InvalidType)
|
|
|
+ 1102 AND NOT SymTab.IsUnresolved(t)
|
|
|
+ 1103 AND (cls # SymTab.ClInt)
|
|
|
+ 1104 AND (cls # SymTab.ClBool)
|
|
|
+ 1105 AND (cls # SymTab.ClChar)
|
|
|
+ 1106 AND (cls # SymTab.ClReal)
|
|
|
+ 1107 AND (cls # SymTab.ClArray)
|
|
|
+ 1108 AND (cls # SymTab.ClSet)
|
|
|
+ 1109 AND (cls # SymTab.ClRecord)
|
|
|
+ 1110 AND (cls # SymTab.ClPtr)
|
|
|
+ 1111 AND (cls # SymTab.ClLong)
|
|
|
+ 1112 AND (cls # SymTab.ClProc)
|
|
|
+ 1113 AND (cls # SymTab.ClUChar)
|
|
|
+ 1114 AND (cls # SymTab.ClUStr)
|
|
|
+ 1115 AND (cls # SymTab.ClEnum)
|
|
|
+ 1116 AND (cls # SymTab.ClClass) THEN
|
|
|
+ 1117 SemError(230) END;
|
|
|
+ 1118 IF QbeGen.LocFull() THEN
|
|
|
+ 1119 SemError(233) END;
|
|
|
+ 1120 i := 0;
|
|
|
+ 1121 IF SymTab.IsUnresolved(t)
|
|
|
+ 1122 AND NOT SymTab.InProc() THEN
|
|
|
+ 1123 (* a forward-typed global:
|
|
|
+ 1124 defer emission until the
|
|
|
+ 1125 TYPE block completes *)
|
|
|
+ 1126 WHILE i < SymTab.PendCount() DO
|
|
|
+ 1127 SymTab.PendName(i, nm);
|
|
|
+ 1128 IF nPendVar <=
|
|
|
+ 1129 HIGH(pendVarName) THEN
|
|
|
+ 1130 pendVarName[nPendVar] := nm;
|
|
|
+ 1131 pendVarT[nPendVar] := t;
|
|
|
+ 1132 INC(nPendVar)
|
|
|
+ 1133 END;
|
|
|
+ 1134 INC(i)
|
|
|
+ 1135 END
|
|
|
+ 1136 ELSE
|
|
|
+ 1137 WHILE i < SymTab.PendCount() DO
|
|
|
+ 1138 SymTab.PendName(i, nm);
|
|
|
+ 1139 QbeGen.DeclVar(nm, t);
|
|
|
+ 1140 INC(i)
|
|
|
+ 1141 END
|
|
|
+ 1142 END;
|
|
|
+ 1143 (* a plain VAR list, not a
|
|
|
+ 1144 heading: the signature
|
|
|
+ 1145 result is discarded *)
|
|
|
+ 1146 IF NOT SymTab.FixPending(t) THEN
|
|
|
+ 1147 END; .) .
|
|
|
+ 1148 VarIdents (. VAR n: SymTab.Name; .)
|
|
|
+ 1149 = GetIdent<n> (. IF NOT SymTab.EnterPending(n,
|
|
|
+ 1150 SymTab.KindVar) THEN
|
|
|
+ 1151 SemError(200) END; .)
|
|
|
+ 1152 { ","
|
|
|
+ 1153 GetIdent<n> (. IF NOT SymTab.EnterPending(n,
|
|
|
+ 1154 SymTab.KindVar) THEN
|
|
|
+ 1155 SemError(200) END; .) } .
|
|
|
+ 1156 ParIdents<isV: BOOLEAN> (. VAR n: SymTab.Name; .)
|
|
|
+ 1157 = GetIdent<n> (. IF NOT SymTab.EnterParam(n, isV) THEN
|
|
|
+ 1158 SemError(200) END; .)
|
|
|
+ 1159 { "," GetIdent<n> (. IF NOT SymTab.EnterParam(n, isV) THEN
|
|
|
+ 1160 SemError(200) END; .) } .
|
|
|
+ 1161 (* Procedure headings enter scopes/params/result and buffer the
|
|
|
+ 1162 QBE header; bodies lower to functions (4.1, module level only).
|
|
|
+ 1163 FORWARD marks; the body heading re-enters (signature compare
|
|
|
+ 1164 deferred). Nested procedures parse + check, lowering = 4.2. *)
|
|
|
+ 1165 ProcHeading<VAR pn: SymTab.Name; methCls: SymTab.TypeIndex>
|
|
|
+ 1166 (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1167 mg: QbeGen.QVal; .)
|
|
|
+ 1168 = "PROCEDURE"
|
|
|
+ 1169 GetIdent<pn> (. IF methCls #
|
|
|
+ 1170 SymTab.InvalidType THEN
|
|
|
+ 1171 (* a method: resume the
|
|
|
+ 1172 declared symbol (reuse
|
|
|
+ 1173 its uid) *)
|
|
|
+ 1174 IF NOT SymTab.ResumeMethod(
|
|
|
+ 1175 methCls, pn) THEN
|
|
|
+ 1176 SemError(200) END
|
|
|
+ 1177 ELSIF NOT SymTab.EnterProc(pn) THEN
|
|
|
+ 1178 IF NOT SymTab.ReenterProc(pn) THEN
|
|
|
+ 1179 IF NOT SymTab.ResumeProc(pn) THEN
|
|
|
+ 1180 SemError(200) END
|
|
|
+ 1181 END
|
|
|
+ 1182 END;
|
|
|
+ 1183 Lower.ScopeEnter;
|
|
|
+ 1184 Lower.NoteProc(pn,
|
|
|
+ 1185 SymTab.ProcUid(pn),
|
|
|
+ 1186 SymTab.InvalidType,
|
|
|
+ 1187 SymTab.ProcDepthOf(pn),
|
|
|
+ 1188 FALSE);
|
|
|
+ 1189 IF methCls #
|
|
|
+ 1190 SymTab.InvalidType THEN
|
|
|
+ 1191 QbeGen.Mangled(pn,
|
|
|
+ 1192 SymTab.MethUid(), mg)
|
|
|
+ 1193 ELSE
|
|
|
+ 1194 QbeGen.Mangled(pn,
|
|
|
+ 1195 SymTab.ProcUid(pn), mg)
|
|
|
+ 1196 END;
|
|
|
+ 1197 QbeGen.BeginFunc(mg);
|
|
|
+ 1198 IF methCls #
|
|
|
+ 1199 SymTab.InvalidType THEN
|
|
|
+ 1200 (* hidden THIS receiver:
|
|
|
+ 1201 a VAR param of the
|
|
|
+ 1202 class type, pushed as
|
|
|
+ 1203 the WITH base *)
|
|
|
+ 1204 IF NOT SymTab.EnterThisParam(
|
|
|
+ 1205 methCls) THEN
|
|
|
+ 1206 SemError(200) END;
|
|
|
+ 1207 IF NOT QbeGen.FuncParam(
|
|
|
+ 1208 "THIS", TRUE,
|
|
|
+ 1209 methCls) THEN
|
|
|
+ 1210 SemError(233) END
|
|
|
+ 1211 END; .)
|
|
|
+ 1212 [ FormalParams ]
|
|
|
+ 1213 [ ":" TypeIdent<t> (. IF NOT SymTab.SetProcRes(t) THEN
|
|
|
+ 1214 SemError(235) END;
|
|
|
+ 1215 Lower.SetProcRes(t);
|
|
|
+ 1216 QbeGen.SetFuncRes(t);
|
|
|
+ 1217 IF (t #
|
|
|
+ 1218 SymTab.InvalidType)
|
|
|
+ 1219 AND ((SymTab.ClassOf(t)
|
|
|
+ 1220 = SymTab.ClArray)
|
|
|
+ 1221 OR (SymTab.ClassOf(t)
|
|
|
+ 1222 = SymTab.ClRecord)
|
|
|
+ 1223 OR (SymTab.ClassOf(t)
|
|
|
+ 1224 = SymTab.ClSet)
|
|
|
+ 1225 OR (SymTab.ClassOf(t)
|
|
|
+ 1226 = SymTab.ClClass)) THEN
|
|
|
+ 1227 SemError(230) END; .) ] .
|
|
|
+ 1228 FormalParams
|
|
|
+ 1229 = "(" [ ParamSection { ";" ParamSection } ] ")" .
|
|
|
+ 1230 ParamSection (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1231 nm: SymTab.Name;
|
|
|
+ 1232 i: CARDINAL;
|
|
|
+ 1233 isV: BOOLEAN; .)
|
|
|
+ 1234 = (. isV := FALSE; .)
|
|
|
+ 1235 [ "VAR" (. isV := TRUE; .) ]
|
|
|
+ 1236 ParIdents<isV> ":" Type<t, TRUE> (. i := 0;
|
|
|
+ 1237 WHILE i < SymTab.PendCount() DO
|
|
|
+ 1238 SymTab.PendName(i, nm);
|
|
|
+ 1239 Lower.NoteParam(nm, t, isV);
|
|
|
+ 1240 Lower.NoteVar(nm, SymTab.KindParam, t);
|
|
|
+ 1241 (* value open arrays are
|
|
|
+ 1242 passed as descriptor
|
|
|
+ 1243 addresses (no copy):
|
|
|
+ 1244 same representation as
|
|
|
+ 1245 VAR formals *)
|
|
|
+ 1246 IF NOT QbeGen.FuncParam(nm,
|
|
|
+ 1247 isV
|
|
|
+ 1248 OR SymTab.IsOpenArray(t),
|
|
|
+ 1249 t) THEN
|
|
|
+ 1250 SemError(233) END;
|
|
|
+ 1251 INC(i)
|
|
|
+ 1252 END;
|
|
|
+ 1253 IF NOT SymTab.FixPending(t) THEN
|
|
|
+ 1254 SemError(235) END; .) .
|
|
|
+ 1255 (* Nested procedures lower like top-level ones (4.2): the
|
|
|
+ 1256 static link gives them their parent's frame. Methods keep
|
|
|
+ 1257 parse-now/230-later. *)
|
|
|
+ 1258 ProcDecl (. VAR pn: SymTab.Name;
|
|
|
+ 1259 astNode: AST.Node; .)
|
|
|
+ 1260 = ProcHeading<pn, SymTab.InvalidType> ";"
|
|
|
+ 1261 (. astNode := AST.MakeNode(AST.NkProcDecl);
|
|
|
+ 1262 AST.SetOp(astNode, 0);
|
|
|
+ 1263 AST.SetChild(astNode, 0,
|
|
|
+ 1264 AST.MakeLeaf(AST.NkIdent, pn));
|
|
|
+ 1265 Lower.NoteProcNode(astNode); .)
|
|
|
+ 1266 ( "FORWARD" (. AST.SetOp(astNode, 1);
|
|
|
+ 1267 astDecl := astNode;
|
|
|
+ 1268 Lower.ScopeLeave;
|
|
|
+ 1269 SymTab.MarkFwd;
|
|
|
+ 1270 SymTab.CloseProc;
|
|
|
+ 1271 QbeGen.AbortFunc; .)
|
|
|
+ 1272 | "EXTERNAL" (. AST.SetOp(astNode, 2);
|
|
|
+ 1273 astDecl := astNode;
|
|
|
+ 1274 Lower.MarkProcExternal;
|
|
|
+ 1275 Lower.ScopeLeave;
|
|
|
+ 1276 SymTab.MarkExternal("");
|
|
|
+ 1277 SymTab.CloseProc;
|
|
|
+ 1278 QbeGen.AbortFunc; .)
|
|
|
+ 1279 | (. QbeGen.EndFuncHeader; .)
|
|
|
+ 1280 Block<pn> (. AST.SetChild(astNode, 1, astStmt);
|
|
|
+ 1281 AST.SetChild(astNode, 2, astBlkDecls);
|
|
|
+ 1282 astDecl := astNode;
|
|
|
+ 1283 Lower.ScopeLeave;
|
|
|
+ 1284 SymTab.CloseProc;
|
|
|
+ 1285 QbeGen.EndFunc(
|
|
|
+ 1286 SymTab.ProcRes(pn)); .) ) .
|
|
|
+ 1287 Block<pn: SymTab.Name> (. VAR m2: SymTab.Name; .)
|
|
|
+ 1288 = DeclSeq (. astBlkDecls := astDecl;
|
|
|
+ 1289 astStmt := AST.NoNode; .)
|
|
|
+ 1290 [ "BEGIN" (. (* an empty body is still a
|
|
|
+ 1291 body: mark it so Lower
|
|
|
+ 1292 does not read it as a
|
|
|
+ 1293 definition heading *)
|
|
|
+ 1294 IF astStmt = AST.NoNode THEN
|
|
|
+ 1295 astStmt :=
|
|
|
+ 1296 AST.MakeNode(AST.NkBlock)
|
|
|
+ 1297 END; .)
|
|
|
+ 1298 [ StatSeq ] ]
|
|
|
+ 1299 "END"
|
|
|
+ 1300 GetIdent<m2> (. IF NOT SymTab.Equal(pn, m2) THEN
|
|
|
+ 1301 SemError(202) END; .) .
|
|
|
+ 1302 StatSeq (. VAR astSeq, astTail: AST.Node; .)
|
|
|
+ 1303 = (. astSeq := AST.NoNode;
|
|
|
+ 1304 astTail := AST.NoNode; .)
|
|
|
+ 1305 Statement (. AstAppend(AST.NkBlock,
|
|
|
+ 1306 astSeq, astTail, astStmt); .)
|
|
|
+ 1307 { ";" [ Statement (. AstAppend(AST.NkBlock,
|
|
|
+ 1308 astSeq, astTail, astStmt); .) ] }
|
|
|
+ 1309 (. astStmt := astSeq; .) .
|
|
|
+ 1310 (* Trailing/empty statements (`a; ; b`, Coco/R's generated `;;`)
|
|
|
+ 1311 are accepted: the statement after ';' is optional. *)
|
|
|
+ 1312 Statement (. VAR lx: QbeGen.QVal; .)
|
|
|
+ 1313 = (. astStmt := AST.NoNode; .)
|
|
|
+ 1314 ( AssOrCall
|
|
|
+ 1315 | IfStat
|
|
|
+ 1316 | WhileStat
|
|
|
+ 1317 | RepeatStat
|
|
|
+ 1318 | LoopStat
|
|
|
+ 1319 | ForStat
|
|
|
+ 1320 | CaseStat
|
|
|
+ 1321 | WithStat
|
|
|
+ 1322 | ReturnStat
|
|
|
+ 1323 | HaltStat
|
|
|
+ 1324 | NewStat
|
|
|
+ 1325 | DisposeStat
|
|
|
+ 1326 | IncDecStat
|
|
|
+ 1327 | InclExclStat
|
|
|
+ 1328 | "EXIT" (. IF QbeGen.TopLoop(lx) THEN
|
|
|
+ 1329 QbeGen.Jmp(lx)
|
|
|
+ 1330 ELSE SemError(230) END;
|
|
|
+ 1331 astStmt := AST.MakeNode(AST.NkExit); .) ) .
|
|
|
+ 1332 (* INCL(set, elem) / EXCL(set, elem): PIM set-element builtins. *)
|
|
|
+ 1333 InclExclStat (. VAR at, et2: SymTab.TypeIndex;
|
|
|
+ 1334 dk: INTEGER;
|
|
|
+ 1335 qd, qe: QbeGen.QVal;
|
|
|
+ 1336 qn: SymTab.Name;
|
|
|
+ 1337 sfx, isInc: BOOLEAN;
|
|
|
+ 1338 astNode, astD: AST.Node; .)
|
|
|
+ 1339 = ( "INCL" (. isInc := TRUE; .)
|
|
|
+ 1340 | "EXCL" (. isInc := FALSE; .) )
|
|
|
+ 1341 "(" Design<at, dk, qd, qn, sfx> (. astD := astCur; .) ","
|
|
|
+ 1342 Expr<et2, qe> ")"
|
|
|
+ 1343 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 1344 IF isInc THEN
|
|
|
+ 1345 AST.SetChild(astNode, 0,
|
|
|
+ 1346 AST.MakeLeaf(AST.NkIdent, "INCL"))
|
|
|
+ 1347 ELSE AST.SetChild(astNode, 0,
|
|
|
+ 1348 AST.MakeLeaf(AST.NkIdent, "EXCL"))
|
|
|
+ 1349 END;
|
|
|
+ 1350 IF astD # AST.NoNode THEN
|
|
|
+ 1351 AST.SetChild(astNode, 1, astD) END;
|
|
|
+ 1352 IF astCur # AST.NoNode THEN
|
|
|
+ 1353 AST.SetChild(astNode, 2, astCur) END;
|
|
|
+ 1354 astStmt := astNode; .)
|
|
|
+ 1355 (. IF at = SymTab.InvalidType THEN
|
|
|
+ 1356 ELSIF SymTab.ClassOf(at) #
|
|
|
+ 1357 SymTab.ClSet THEN
|
|
|
+ 1358 SemError(222)
|
|
|
+ 1359 ELSE
|
|
|
+ 1360 IF isInc THEN
|
|
|
+ 1361 QbeGen.SetBit(qd, qe,
|
|
|
+ 1362 SymTab.SetBaseLo(at),
|
|
|
+ 1363 SymTab.SetCount(at))
|
|
|
+ 1364 ELSE
|
|
|
+ 1365 QbeGen.SetClearBit(qd, qe,
|
|
|
+ 1366 SymTab.SetBaseLo(at),
|
|
|
+ 1367 SymTab.SetCount(at))
|
|
|
+ 1368 END
|
|
|
+ 1369 END; .) .
|
|
|
+ 1370 (* INC(v [,step]) / DEC(v [,step]) as builtin statements over an
|
|
|
+ 1371 integer designator. *)
|
|
|
+ 1372 IncDecStat (. VAR dt, et2: SymTab.TypeIndex;
|
|
|
+ 1373 dk: INTEGER;
|
|
|
+ 1374 qd, qv, qn2, qstep:
|
|
|
+ 1375 QbeGen.QVal;
|
|
|
+ 1376 qn: SymTab.Name;
|
|
|
+ 1377 sfx, isInc: BOOLEAN;
|
|
|
+ 1378 astNode, astD, astStep:
|
|
|
+ 1379 AST.Node; .)
|
|
|
+ 1380 = (. isInc := TRUE; .)
|
|
|
+ 1381 ( "INC" (. isInc := TRUE; .)
|
|
|
+ 1382 | "DEC" (. isInc := FALSE; .) )
|
|
|
+ 1383 "(" (. QbeGen.CopyOp("1", qstep); astStep := AST.NoNode; .)
|
|
|
+ 1384 Design<dt, dk, qd, qn, sfx> (. astD := astCur; .)
|
|
|
+ 1385 [ "," Expr<et2, qstep> (. astStep := astCur; .) ]
|
|
|
+ 1386 ")" (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 1387 IF isInc THEN
|
|
|
+ 1388 AST.SetChild(astNode, 0,
|
|
|
+ 1389 AST.MakeLeaf(AST.NkIdent, "INC"))
|
|
|
+ 1390 ELSE AST.SetChild(astNode, 0,
|
|
|
+ 1391 AST.MakeLeaf(AST.NkIdent, "DEC"))
|
|
|
+ 1392 END;
|
|
|
+ 1393 IF astD # AST.NoNode THEN
|
|
|
+ 1394 AST.SetChild(astNode, 1, astD) END;
|
|
|
+ 1395 IF astStep # AST.NoNode THEN
|
|
|
+ 1396 AST.SetChild(astNode, 2, astStep) END;
|
|
|
+ 1397 astStmt := astNode; .) (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 1398 ELSIF (dk # SymTab.KindVar)
|
|
|
+ 1399 AND (dk # SymTab.KindParam)
|
|
|
+ 1400 AND (dk # SymTab.KindField) THEN
|
|
|
+ 1401 SemError(210)
|
|
|
+ 1402 ELSIF NOT SymTab.IsIntFamily(dt) THEN
|
|
|
+ 1403 SemError(211)
|
|
|
+ 1404 ELSE
|
|
|
+ 1405 IF sfx
|
|
|
+ 1406 OR (dk = SymTab.KindField) THEN
|
|
|
+ 1407 QbeGen.ElemLoad(qd, dt, qv)
|
|
|
+ 1408 ELSE QbeGen.LoadVar(qn,
|
|
|
+ 1409 FALSE, qv)
|
|
|
+ 1410 END;
|
|
|
+ 1411 QbeGen.NewTemp(qn2);
|
|
|
+ 1412 IF isInc THEN
|
|
|
+ 1413 QbeGen.Op3("add", qn2, qv,
|
|
|
+ 1414 qstep, FALSE)
|
|
|
+ 1415 ELSE QbeGen.Op3("sub", qn2, qv,
|
|
|
+ 1416 qstep, FALSE)
|
|
|
+ 1417 END;
|
|
|
+ 1418 IF sfx
|
|
|
+ 1419 OR (dk = SymTab.KindField) THEN
|
|
|
+ 1420 QbeGen.ElemStore(qd, qn2,
|
|
|
+ 1421 dt)
|
|
|
+ 1422 ELSE QbeGen.StoreVar(qn,
|
|
|
+ 1423 qn2, FALSE)
|
|
|
+ 1424 END
|
|
|
+ 1425 END; .) .
|
|
|
+ 1426 (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
|
|
|
+ 1427 Targets are pointer designators; DISPOSE nils afterwards (safer
|
|
|
+ 1428 than Wirth-undefined; documented). DISPOSE is shallow. *)
|
|
|
+ 1429 NewStat (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 1430 dk: INTEGER;
|
|
|
+ 1431 qd, qm: QbeGen.QVal;
|
|
|
+ 1432 qn: SymTab.Name;
|
|
|
+ 1433 sfx: BOOLEAN;
|
|
|
+ 1434 bt: SymTab.TypeIndex;
|
|
|
+ 1435 astNode, astD: AST.Node; .)
|
|
|
+ 1436 = "NEW" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
|
|
|
+ 1437 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 1438 AST.SetChild(astNode, 0,
|
|
|
+ 1439 AST.MakeLeaf(AST.NkIdent, "NEW"));
|
|
|
+ 1440 IF astD # AST.NoNode THEN
|
|
|
+ 1441 AST.SetChild(astNode, 1, astD) END;
|
|
|
+ 1442 astStmt := astNode; .)
|
|
|
+ 1443 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 1444 ELSIF (dk # SymTab.KindVar)
|
|
|
+ 1445 AND (dk # SymTab.KindParam)
|
|
|
+ 1446 AND (dk # SymTab.KindField) THEN
|
|
|
+ 1447 SemError(210)
|
|
|
+ 1448 ELSIF SymTab.ClassOf(dt) #
|
|
|
+ 1449 SymTab.ClPtr THEN
|
|
|
+ 1450 SemError(219)
|
|
|
+ 1451 ELSE bt := SymTab.PtrBase(dt);
|
|
|
+ 1452 IF bt #
|
|
|
+ 1453 SymTab.InvalidType THEN
|
|
|
+ 1454 QbeGen.NewHeap(bt, qm);
|
|
|
+ 1455 QbeGen.InitHeap(qm, bt);
|
|
|
+ 1456 IF sfx
|
|
|
+ 1457 OR (dk =
|
|
|
+ 1458 SymTab.KindField) THEN
|
|
|
+ 1459 QbeGen.ElemStore(qd, qm,
|
|
|
+ 1460 dt)
|
|
|
+ 1461 ELSE QbeGen.StorePtr(qn,
|
|
|
+ 1462 qm)
|
|
|
+ 1463 END
|
|
|
+ 1464 END
|
|
|
+ 1465 END; .) .
|
|
|
+ 1466 DisposeStat (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 1467 dk: INTEGER;
|
|
|
+ 1468 qd, qv: QbeGen.QVal;
|
|
|
+ 1469 qn: SymTab.Name;
|
|
|
+ 1470 sfx: BOOLEAN;
|
|
|
+ 1471 astNode, astD: AST.Node; .)
|
|
|
+ 1472 = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
|
|
|
+ 1473 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 1474 AST.SetChild(astNode, 0,
|
|
|
+ 1475 AST.MakeLeaf(AST.NkIdent, "DISPOSE"));
|
|
|
+ 1476 IF astD # AST.NoNode THEN
|
|
|
+ 1477 AST.SetChild(astNode, 1, astD) END;
|
|
|
+ 1478 astStmt := astNode; .)
|
|
|
+ 1479 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 1480 ELSIF (dk # SymTab.KindVar)
|
|
|
+ 1481 AND (dk # SymTab.KindParam)
|
|
|
+ 1482 AND (dk # SymTab.KindField) THEN
|
|
|
+ 1483 SemError(210)
|
|
|
+ 1484 ELSIF SymTab.ClassOf(dt) #
|
|
|
+ 1485 SymTab.ClPtr THEN
|
|
|
+ 1486 SemError(219)
|
|
|
+ 1487 ELSE
|
|
|
+ 1488 IF sfx
|
|
|
+ 1489 OR (dk =
|
|
|
+ 1490 SymTab.KindField) THEN
|
|
|
+ 1491 QbeGen.ElemLoad(qd, dt,
|
|
|
+ 1492 qv)
|
|
|
+ 1493 ELSE QbeGen.LoadPtr(qn, qv)
|
|
|
+ 1494 END;
|
|
|
+ 1495 QbeGen.FreeHeap(qv);
|
|
|
+ 1496 IF sfx
|
|
|
+ 1497 OR (dk =
|
|
|
+ 1498 SymTab.KindField) THEN
|
|
|
+ 1499 QbeGen.ElemStore(qd, "0",
|
|
|
+ 1500 dt)
|
|
|
+ 1501 ELSE QbeGen.StorePtr(qn,
|
|
|
+ 1502 "0")
|
|
|
+ 1503 END
|
|
|
+ 1504 END; .) .
|
|
|
+ 1505 (* WITH pushes each record's fields (inner wins) plus its base
|
|
|
+ 1506 address; field designators resolve through both stacks. *)
|
|
|
+ 1507 WithStat (. VAR nW: CARDINAL;
|
|
|
+ 1508 astNode: AST.Node; .)
|
|
|
+ 1509 = "WITH" (. nW := 0;
|
|
|
+ 1510 astNode := AST.MakeNode(AST.NkWith); .)
|
|
|
+ 1511 WithItem<nW, astNode> { "," WithItem<nW, astNode> }
|
|
|
+ 1512 "DO" (. astStmt := AST.NoNode; .)
|
|
|
+ 1513 [ StatSeq ] "END" (. AST.SetChild(astNode,
|
|
|
+ 1514 AST.NChild(astNode), astStmt);
|
|
|
+ 1515 astStmt := astNode;
|
|
|
+ 1516 WHILE nW > 0 DO
|
|
|
+ 1517 SymTab.PopScope;
|
|
|
+ 1518 QbeGen.PopWith;
|
|
|
+ 1519 DEC(nW)
|
|
|
+ 1520 END; .) .
|
|
|
+ 1521 WithItem<VAR nW: CARDINAL; wnode: AST.Node>
|
|
|
+ 1522 (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 1523 dk: INTEGER;
|
|
|
+ 1524 qd, qe: QbeGen.QVal;
|
|
|
+ 1525 qn: SymTab.Name;
|
|
|
+ 1526 sfx: BOOLEAN; .)
|
|
|
+ 1527 = Design<dt, dk, qd, qn, sfx>
|
|
|
+ 1528 (. IF astCur # AST.NoNode THEN
|
|
|
+ 1529 AST.SetChild(wnode,
|
|
|
+ 1530 AST.NChild(wnode), astCur) END;
|
|
|
+ 1531 IF dt = SymTab.InvalidType THEN
|
|
|
+ 1532 ELSIF (SymTab.ClassOf(dt) #
|
|
|
+ 1533 SymTab.ClRecord)
|
|
|
+ 1534 AND (SymTab.ClassOf(dt) #
|
|
|
+ 1535 SymTab.ClClass) THEN
|
|
|
+ 1536 SemError(215)
|
|
|
+ 1537 ELSIF SymTab.PushRecord(dt) THEN
|
|
|
+ 1538 QbeGen.PushWith(qd);
|
|
|
+ 1539 INC(nW)
|
|
|
+ 1540 END; .) .
|
|
|
+ 1541 (* Assignment or procedure-statement call (4.1, module level).
|
|
|
+ 1542 Bare `P;` is a syntax error; function-as-statement is 233. *)
|
|
|
+ 1543 AssOrCall (. VAR dt, et: SymTab.TypeIndex;
|
|
|
+ 1544 dk: INTEGER;
|
|
|
+ 1545 qd, qe, qt, ql: QbeGen.QVal;
|
|
|
+ 1546 qn: SymTab.Name;
|
|
|
+ 1547 ct2, res0: SymTab.TypeIndex;
|
|
|
+ 1548 q2, mg0: QbeGen.QVal;
|
|
|
+ 1549 isR, conv, wconv: BOOLEAN;
|
|
|
+ 1550 called, sfx: BOOLEAN;
|
|
|
+ 1551 astLhs: AST.Node; .)
|
|
|
+ 1552 = Design<dt, dk, qd, qn, sfx>
|
|
|
+ 1553 (. astLhs := astCur; astNArgs := 0; .)
|
|
|
+ 1554 ( ":="
|
|
|
+ 1555 Expr<et, qe> (. astStmt := AST.MakeBin(
|
|
|
+ 1556 AST.NkAssign, 0, astLhs, astCur);
|
|
|
+ 1557 IF (dt # SymTab.InvalidType)
|
|
|
+ 1558 AND (dk # SymTab.KindVar)
|
|
|
+ 1559 AND (dk # SymTab.KindParam)
|
|
|
+ 1560 AND (dk # SymTab.KindField) THEN
|
|
|
+ 1561 SemError(210)
|
|
|
+ 1562 ELSIF NOT SymTab.Assignable(et,
|
|
|
+ 1563 dt) THEN
|
|
|
+ 1564 SemError(210)
|
|
|
+ 1565 ELSIF (dt # SymTab.InvalidType)
|
|
|
+ 1566 AND (SymTab.ClassOf(dt) =
|
|
|
+ 1567 SymTab.ClClass) THEN
|
|
|
+ 1568 SemError(230) END;
|
|
|
+ 1569 isR := (dt #
|
|
|
+ 1570 SymTab.InvalidType)
|
|
|
+ 1571 AND (SymTab.ClassOf(dt)
|
|
|
+ 1572 = SymTab.ClReal);
|
|
|
+ 1573 conv := isR
|
|
|
+ 1574 AND SymTab.IsIntFamily(et);
|
|
|
+ 1575 wconv := (dt #
|
|
|
+ 1576 SymTab.InvalidType)
|
|
|
+ 1577 AND SymTab.IsLongFamily(dt)
|
|
|
+ 1578 AND SymTab.IsIntFamily(et);
|
|
|
+ 1579 IF ((dk = SymTab.KindVar)
|
|
|
+ 1580 OR (dk = SymTab.KindParam)
|
|
|
+ 1581 OR (dk = SymTab.KindField))
|
|
|
+ 1582 AND (dt # SymTab.InvalidType)
|
|
|
+ 1583 AND (et # SymTab.InvalidType)
|
|
|
+ 1584 AND (SymTab.ClassOf(dt) #
|
|
|
+ 1585 SymTab.ClClass) THEN
|
|
|
+ 1586 IF sfx
|
|
|
+ 1587 OR (dk = SymTab.KindField) THEN
|
|
|
+ 1588 IF SymTab.ClassOf(dt) =
|
|
|
+ 1589 SymTab.ClArray THEN
|
|
|
+ 1590 IF (et # SymTab.InvalidType)
|
|
|
+ 1591 AND (SymTab.ClassOf(et) = SymTab.ClUStr)
|
|
|
+ 1592 AND SymTab.IsUCharArray(dt) THEN
|
|
|
+ 1593 QbeGen.UAssign(qd, qe)
|
|
|
+ 1594 ELSIF SymTab.StrCompat(dt,
|
|
|
+ 1595 et) THEN
|
|
|
+ 1596 QbeGen.StrAssign(qd,
|
|
|
+ 1597 qe)
|
|
|
+ 1598 ELSE
|
|
|
+ 1599 QbeGen.CopyArray(qd,
|
|
|
+ 1600 qe, dt)
|
|
|
+ 1601 END
|
|
|
+ 1602 ELSIF SymTab.ClassOf(dt) =
|
|
|
+ 1603 SymTab.ClSet THEN
|
|
|
+ 1604 QbeGen.CopySet(qd, qe,
|
|
|
+ 1605 SymTab.SetWords(dt),
|
|
|
+ 1606 SymTab.SetWords(et))
|
|
|
+ 1607 ELSIF SymTab.ClassOf(dt) =
|
|
|
+ 1608 SymTab.ClRecord THEN
|
|
|
+ 1609 QbeGen.CopyRecord(qd, qe,
|
|
|
+ 1610 dt)
|
|
|
+ 1611 ELSIF SymTab.IsLongFamily(dt) THEN
|
|
|
+ 1612 IF wconv THEN
|
|
|
+ 1613 QbeGen.WidenLong(qe, ql);
|
|
|
+ 1614 QbeGen.ElemStore(qd, ql,
|
|
|
+ 1615 dt)
|
|
|
+ 1616 ELSE QbeGen.ElemStore(qd, qe,
|
|
|
+ 1617 dt)
|
|
|
+ 1618 END
|
|
|
+ 1619 ELSIF conv THEN
|
|
|
+ 1620 QbeGen.ConvIR(qe, qt);
|
|
|
+ 1621 QbeGen.ElemStore(qd, qt,
|
|
|
+ 1622 dt)
|
|
|
+ 1623 ELSE QbeGen.ElemStore(qd, qe,
|
|
|
+ 1624 dt)
|
|
|
+ 1625 END
|
|
|
+ 1626 ELSIF SymTab.ClassOf(dt) =
|
|
|
+ 1627 SymTab.ClArray THEN
|
|
|
+ 1628 IF (et # SymTab.InvalidType)
|
|
|
+ 1629 AND (SymTab.ClassOf(et) = SymTab.ClUStr)
|
|
|
+ 1630 AND SymTab.IsUCharArray(dt) THEN
|
|
|
+ 1631 QbeGen.UAssign(qd, qe)
|
|
|
+ 1632 ELSIF SymTab.StrCompat(dt,
|
|
|
+ 1633 et) THEN
|
|
|
+ 1634 QbeGen.StrAssign(qd, qe)
|
|
|
+ 1635 ELSE
|
|
|
+ 1636 QbeGen.CopyArray(qd, qe,
|
|
|
+ 1637 dt)
|
|
|
+ 1638 END
|
|
|
+ 1639 ELSIF SymTab.ClassOf(dt) =
|
|
|
+ 1640 SymTab.ClSet THEN
|
|
|
+ 1641 QbeGen.CopySet(qd, qe,
|
|
|
+ 1642 SymTab.SetWords(dt),
|
|
|
+ 1643 SymTab.SetWords(et))
|
|
|
+ 1644 ELSIF SymTab.ClassOf(dt) =
|
|
|
+ 1645 SymTab.ClRecord THEN
|
|
|
+ 1646 QbeGen.CopyRecord(qd, qe, dt)
|
|
|
+ 1647 ELSIF (SymTab.ClassOf(dt) =
|
|
|
+ 1648 SymTab.ClPtr)
|
|
|
+ 1649 OR (SymTab.ClassOf(dt) =
|
|
|
+ 1650 SymTab.ClProc) THEN
|
|
|
+ 1651 QbeGen.StorePtr(qn, qe)
|
|
|
+ 1652 ELSIF SymTab.IsLongFamily(dt) THEN
|
|
|
+ 1653 IF wconv THEN
|
|
|
+ 1654 QbeGen.WidenLong(qe, ql);
|
|
|
+ 1655 QbeGen.StoreLong(qn, ql)
|
|
|
+ 1656 ELSE QbeGen.StoreLong(qn, qe)
|
|
|
+ 1657 END
|
|
|
+ 1658 ELSIF conv THEN
|
|
|
+ 1659 QbeGen.ConvIR(qe, qt);
|
|
|
+ 1660 QbeGen.StoreVar(qn, qt, TRUE)
|
|
|
+ 1661 ELSE
|
|
|
+ 1662 QbeGen.StoreVar(qn, qe, isR)
|
|
|
+ 1663 END
|
|
|
+ 1664 END; .)
|
|
|
+ 1665 | ArgList<qn, dt, qd, FALSE, FALSE, methCls, ct2, q2, called>
|
|
|
+ 1666 (. astStmt := AstCallNode(astLhs); .)
|
|
|
+ 1667 | (* bare `P;`: proper parameterless
|
|
|
+ 1668 procedure call; anything else
|
|
|
+ 1669 here is 233 (was a bare syntax
|
|
|
+ 1670 error before 4.2) *)
|
|
|
+ 1671 (. astStmt := AstCallNode(astLhs);
|
|
|
+ 1672 IF (dk = SymTab.KindProc)
|
|
|
+ 1673 AND NOT sfx THEN
|
|
|
+ 1674 res0 := SymTab.ProcRes(qn);
|
|
|
+ 1675 IF res0 #
|
|
|
+ 1676 SymTab.InvalidType THEN
|
|
|
+ 1677 SemError(233)
|
|
|
+ 1678 ELSIF SymTab.ProcNPar(qn) #
|
|
|
+ 1679 0 THEN
|
|
|
+ 1680 SemError(233)
|
|
|
+ 1681 ELSE QbeGen.Mangled(qn,
|
|
|
+ 1682 SymTab.ProcUid(qn), mg0);
|
|
|
+ 1683 QbeGen.CallBegin(mg0,
|
|
|
+ 1684 res0,
|
|
|
+ 1685 SymTab.ProcDepthOf(qn),
|
|
|
+ 1686 SymTab.IsExternal(qn));
|
|
|
+ 1687 QbeGen.CallEnd(FALSE, q2)
|
|
|
+ 1688 END
|
|
|
+ 1689 ELSE SemError(233)
|
|
|
+ 1690 END; .) ) .
|
|
|
+ 1691 (* Actual-parameter list shared by statement and expression calls.
|
|
|
+ 1692 want selects CallEnd's result handling; t/q carry the call
|
|
|
+ 1693 value (statement calls discard). Arity/type failures are 233;
|
|
|
+ 1694 evaluation code still emits so the .ssa stays assembleable. *)
|
|
|
+ 1695 ArgList<pn: SymTab.Name; pt: SymTab.TypeIndex; callee: QbeGen.QVal;
|
|
|
+ 1696 want: BOOLEAN; soft: BOOLEAN; methCls: SymTab.TypeIndex;
|
|
|
+ 1697 VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
|
|
|
+ 1698 VAR called: BOOLEAN> (. VAR i, np: CARDINAL;
|
|
|
+ 1699 vs: INTEGER;
|
|
|
+ 1700 res: SymTab.TypeIndex;
|
|
|
+ 1701 mg: QbeGen.QVal;
|
|
|
+ 1702 ok, ind, isMeth, va: BOOLEAN; .)
|
|
|
+ 1703 = "(" (. called := TRUE;
|
|
|
+ 1704 ok := TRUE;
|
|
|
+ 1705 ind := FALSE;
|
|
|
+ 1706 isMeth := methCls #
|
|
|
+ 1707 SymTab.InvalidType;
|
|
|
+ 1708 IF isMeth THEN
|
|
|
+ 1709 (* class method: the
|
|
|
+ 1710 receiver is armed.
|
|
|
+ 1711 Virtual -> dispatch
|
|
|
+ 1712 through the vtable;
|
|
|
+ 1713 otherwise a static
|
|
|
+ 1714 call. *)
|
|
|
+ 1715 res := SymTab.ClassMethodRes(
|
|
|
+ 1716 methCls, pn);
|
|
|
+ 1717 vs := SymTab.VirtSlot(
|
|
|
+ 1718 methCls, pn);
|
|
|
+ 1719 IF vs >= 0 THEN
|
|
|
+ 1720 QbeGen.VirtCallBegin(
|
|
|
+ 1721 callee, vs, res)
|
|
|
+ 1722 ELSE
|
|
|
+ 1723 QbeGen.Mangled(pn,
|
|
|
+ 1724 SymTab.ClassMethodUid(
|
|
|
+ 1725 methCls, pn), mg);
|
|
|
+ 1726 QbeGen.CallBegin(mg, res, 0,
|
|
|
+ 1727 FALSE)
|
|
|
+ 1728 END
|
|
|
+ 1729 ELSIF SymTab.SymKind(pn) =
|
|
|
+ 1730 SymTab.KindProc THEN
|
|
|
+ 1731 res := SymTab.ProcRes(pn);
|
|
|
+ 1732 QbeGen.Mangled(pn,
|
|
|
+ 1733 SymTab.ProcUid(pn), mg);
|
|
|
+ 1734 QbeGen.CallBegin(mg, res,
|
|
|
+ 1735 SymTab.ProcDepthOf(pn),
|
|
|
+ 1736 SymTab.IsExternal(pn))
|
|
|
+ 1737 ELSIF (pt # SymTab.InvalidType)
|
|
|
+ 1738 AND (SymTab.ClassOf(pt) = SymTab.ClProc) THEN
|
|
|
+ 1739 ind := TRUE;
|
|
|
+ 1740 res :=
|
|
|
+ 1741 SymTab.ProcTypeRes(pt);
|
|
|
+ 1742 QbeGen.CallBeginInd(callee,
|
|
|
+ 1743 res, FALSE)
|
|
|
+ 1744 ELSE SemError(233);
|
|
|
+ 1745 ok := FALSE;
|
|
|
+ 1746 res := SymTab.InvalidType
|
|
|
+ 1747 END;
|
|
|
+ 1748 i := 0; .)
|
|
|
+ 1749 [ ActParam<pn, pt, ind, methCls, i> (. INC(i); .)
|
|
|
+ 1750 { "," ActParam<pn, pt, ind, methCls, i> (. INC(i); .) } ]
|
|
|
+ 1751 ")" (. IF ok THEN
|
|
|
+ 1752 IF isMeth THEN
|
|
|
+ 1753 np := SymTab.ClassMethodNPar(
|
|
|
+ 1754 methCls, pn)
|
|
|
+ 1755 ELSIF ind THEN
|
|
|
+ 1756 np := SymTab.ProcTypeNPar(pt)
|
|
|
+ 1757 ELSE np := SymTab.ProcNPar(pn)
|
|
|
+ 1758 END;
|
|
|
+ 1759 va := (NOT isMeth) AND (NOT ind)
|
|
|
+ 1760 AND (SymTab.SymKind(pn) =
|
|
|
+ 1761 SymTab.KindProc)
|
|
|
+ 1762 AND SymTab.Varargs(pn);
|
|
|
+ 1763 IF (i # np) AND NOT va THEN
|
|
|
+ 1764 SemError(233); ok := FALSE
|
|
|
+ 1765 END
|
|
|
+ 1766 END;
|
|
|
+ 1767 IF NOT ok THEN
|
|
|
+ 1768 t := SymTab.InvalidType;
|
|
|
+ 1769 QbeGen.CopyOp("0", q)
|
|
|
+ 1770 ELSIF want THEN
|
|
|
+ 1771 IF res =
|
|
|
+ 1772 SymTab.InvalidType THEN
|
|
|
+ 1773 SemError(233);
|
|
|
+ 1774 t := SymTab.InvalidType;
|
|
|
+ 1775 QbeGen.CopyOp("0", q)
|
|
|
+ 1776 ELSE t := res;
|
|
|
+ 1777 QbeGen.CallEnd(TRUE, q)
|
|
|
+ 1778 END
|
|
|
+ 1779 ELSE
|
|
|
+ 1780 IF res #
|
|
|
+ 1781 SymTab.InvalidType THEN
|
|
|
+ 1782 SemError(233)
|
|
|
+ 1783 END;
|
|
|
+ 1784 t := SymTab.InvalidType;
|
|
|
+ 1785 QbeGen.CopyOp("0", q);
|
|
|
+ 1786 QbeGen.CallEnd(FALSE, q)
|
|
|
+ 1787 END; .) .
|
|
|
+ 1788 (* One actual: VAR formals take recorded designator addresses
|
|
|
+ 1789 (233 otherwise); value formals take converted expressions. *)
|
|
|
+ 1790 ActParam<pn: SymTab.Name; pt: SymTab.TypeIndex; ind: BOOLEAN;
|
|
|
+ 1791 methCls: SymTab.TypeIndex; i: CARDINAL>
|
|
|
+ 1792 (. VAR at, ft: SymTab.TypeIndex;
|
|
|
+ 1793 qe, qa, qt: QbeGen.QVal;
|
|
|
+ 1794 isV, conv, va: BOOLEAN;
|
|
|
+ 1795 cl: CHAR;
|
|
|
+ 1796 savedN, aj: CARDINAL;
|
|
|
+ 1797 savedArgs: ARRAY [0 .. 31]
|
|
|
+ 1798 OF AST.Node; .)
|
|
|
+ 1799 = (. (* Parsing the actual can clobber
|
|
|
+ 1800 the enclosing call's argument
|
|
|
+ 1801 list (Factor resets astNArgs),
|
|
|
+ 1802 so save/restore it. *)
|
|
|
+ 1803 savedN := astNArgs; aj := 0;
|
|
|
+ 1804 WHILE aj <= HIGH(astArgs) DO
|
|
|
+ 1805 savedArgs[aj] := astArgs[aj];
|
|
|
+ 1806 INC(aj)
|
|
|
+ 1807 END; .)
|
|
|
+ 1808 Expr<at, qe> (. astNArgs := savedN; aj := 0;
|
|
|
+ 1809 WHILE aj <= HIGH(astArgs) DO
|
|
|
+ 1810 astArgs[aj] := savedArgs[aj];
|
|
|
+ 1811 INC(aj)
|
|
|
+ 1812 END;
|
|
|
+ 1813 IF astNArgs <= HIGH(astArgs) THEN
|
|
|
+ 1814 astArgs[astNArgs] := astCur;
|
|
|
+ 1815 INC(astNArgs)
|
|
|
+ 1816 END;
|
|
|
+ 1817 va := (NOT ind)
|
|
|
+ 1818 AND (methCls =
|
|
|
+ 1819 SymTab.InvalidType)
|
|
|
+ 1820 AND (SymTab.SymKind(pn) =
|
|
|
+ 1821 SymTab.KindProc)
|
|
|
+ 1822 AND SymTab.Varargs(pn);
|
|
|
+ 1823 IF ind THEN
|
|
|
+ 1824 ft :=
|
|
|
+ 1825 SymTab.ProcTypeParamType(pt,
|
|
|
+ 1826 i);
|
|
|
+ 1827 isV :=
|
|
|
+ 1828 SymTab.ProcTypeParamIsVar(pt,
|
|
|
+ 1829 i)
|
|
|
+ 1830 ELSIF methCls #
|
|
|
+ 1831 SymTab.InvalidType THEN
|
|
|
+ 1832 ft :=
|
|
|
+ 1833 SymTab.ClassMethodParamType(
|
|
|
+ 1834 methCls, pn, i);
|
|
|
+ 1835 isV :=
|
|
|
+ 1836 SymTab.ClassMethodParamIsVar(
|
|
|
+ 1837 methCls, pn, i)
|
|
|
+ 1838 ELSE
|
|
|
+ 1839 ft := SymTab.ParamType(pn, i);
|
|
|
+ 1840 isV := SymTab.ParamIsVar(pn, i)
|
|
|
+ 1841 END;
|
|
|
+ 1842 IF (at = SymTab.InvalidType) THEN
|
|
|
+ 1843 ELSIF ft = SymTab.InvalidType THEN
|
|
|
+ 1844 IF va THEN
|
|
|
+ 1845 QbeGen.CArgAdd(qe, at, qa, cl)
|
|
|
+ 1846 END
|
|
|
+ 1847 ELSIF isV THEN
|
|
|
+ 1848 IF (SymTab.ClassOf(at)
|
|
|
+ 1849 = SymTab.ClChar)
|
|
|
+ 1850 AND (SymTab.ClassOf(ft) = SymTab.ClArray)
|
|
|
+ 1851 AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
|
|
|
+ 1852 = SymTab.ClChar)
|
|
|
+ 1853 AND QbeGen.IsImm(qe) THEN
|
|
|
+ 1854 (* 1-char string
|
|
|
+ 1855 literal passed to
|
|
|
+ 1856 a VAR ARRAY OF CHAR *)
|
|
|
+ 1857 QbeGen.DeclCharStr(qe,
|
|
|
+ 1858 qa);
|
|
|
+ 1859 IF NOT QbeGen.CallArg(qa,
|
|
|
+ 1860 "l") THEN
|
|
|
+ 1861 SemError(233)
|
|
|
+ 1862 END
|
|
|
+ 1863 ELSIF NOT QbeGen.AddrOfVal(qe,
|
|
|
+ 1864 qa) THEN
|
|
|
+ 1865 SemError(233)
|
|
|
+ 1866 ELSIF NOT SymTab.VarParamOk(at,
|
|
|
+ 1867 ft) THEN
|
|
|
+ 1868 SemError(233)
|
|
|
+ 1869 ELSIF NOT QbeGen.CallArg(qa,
|
|
|
+ 1870 "l") THEN
|
|
|
+ 1871 SemError(233)
|
|
|
+ 1872 END
|
|
|
+ 1873 ELSE
|
|
|
+ 1874 IF (SymTab.ClassOf(at)
|
|
|
+ 1875 = SymTab.ClChar)
|
|
|
+ 1876 AND (SymTab.ClassOf(ft) = SymTab.ClArray)
|
|
|
+ 1877 AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
|
|
|
+ 1878 = SymTab.ClChar)
|
|
|
+ 1879 AND QbeGen.IsImm(qe) THEN
|
|
|
+ 1880 (* 1-char string
|
|
|
+ 1881 literal passed to
|
|
|
+ 1882 ARRAY OF CHAR *)
|
|
|
+ 1883 QbeGen.DeclCharStr(qe,
|
|
|
+ 1884 qa);
|
|
|
+ 1885 IF NOT QbeGen.CallArg(qa,
|
|
|
+ 1886 "l") THEN
|
|
|
+ 1887 SemError(233)
|
|
|
+ 1888 END
|
|
|
+ 1889 ELSIF NOT SymTab.Assignable(at,
|
|
|
+ 1890 ft) THEN
|
|
|
+ 1891 SemError(233)
|
|
|
+ 1892 ELSE
|
|
|
+ 1893 conv := (SymTab.ClassOf(
|
|
|
+ 1894 ft) = SymTab.ClReal)
|
|
|
+ 1895 AND SymTab.IsIntFamily(at);
|
|
|
+ 1896 IF conv THEN
|
|
|
+ 1897 QbeGen.ConvIR(qe, qt);
|
|
|
+ 1898 IF NOT QbeGen.CallArg(qt,
|
|
|
+ 1899 "d") THEN
|
|
|
+ 1900 SemError(233)
|
|
|
+ 1901 END
|
|
|
+ 1902 ELSIF NOT QbeGen.CallArg(qe,
|
|
|
+ 1903 QbeGen.ArgClass(ft)) THEN
|
|
|
+ 1904 SemError(233)
|
|
|
+ 1905 END
|
|
|
+ 1906 END
|
|
|
+ 1907 END; .) .
|
|
|
+ 1908 IfStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1909 q, lThen, lElse, lEnd:
|
|
|
+ 1910 QbeGen.QVal;
|
|
|
+ 1911 hasElse: BOOLEAN;
|
|
|
+ 1912 astCond, astIf, astLast,
|
|
|
+ 1913 astNode: AST.Node; .)
|
|
|
+ 1914 = "IF" (. hasElse := FALSE; .)
|
|
|
+ 1915 Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
|
|
|
+ 1916 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
+ 1917 SemError(214) END;
|
|
|
+ 1918 QbeGen.NewLabel(lThen);
|
|
|
+ 1919 QbeGen.NewLabel(lElse);
|
|
|
+ 1920 QbeGen.NewLabel(lEnd);
|
|
|
+ 1921 QbeGen.Jnz(q, lThen, lElse);
|
|
|
+ 1922 QbeGen.EmitLabel(lThen); .)
|
|
|
+ 1923 "THEN" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkIf);
|
|
|
+ 1924 AST.SetChild(astNode, 0, astCond);
|
|
|
+ 1925 AST.SetChild(astNode, 1, astStmt);
|
|
|
+ 1926 astIf := astNode;
|
|
|
+ 1927 astLast := astNode;
|
|
|
+ 1928 QbeGen.Jmp(lEnd); .)
|
|
|
+ 1929 { "ELSIF" (. QbeGen.EmitLabel(lElse);
|
|
|
+ 1930 QbeGen.NewLabel(lElse); .)
|
|
|
+ 1931 Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
|
|
|
+ 1932 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
+ 1933 SemError(214) END;
|
|
|
+ 1934 QbeGen.NewLabel(lThen);
|
|
|
+ 1935 QbeGen.Jnz(q, lThen, lElse);
|
|
|
+ 1936 QbeGen.EmitLabel(lThen); .)
|
|
|
+ 1937 "THEN" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkIf);
|
|
|
+ 1938 AST.SetChild(astNode, 0, astCond);
|
|
|
+ 1939 AST.SetChild(astNode, 1, astStmt);
|
|
|
+ 1940 AST.SetChild(astLast, 2, astNode);
|
|
|
+ 1941 astLast := astNode;
|
|
|
+ 1942 QbeGen.Jmp(lEnd); .) }
|
|
|
+ 1943 [ "ELSE" (. QbeGen.EmitLabel(lElse);
|
|
|
+ 1944 hasElse := TRUE;
|
|
|
+ 1945 astStmt := AST.NoNode; .)
|
|
|
+ 1946 [ StatSeq ] (. AST.SetChild(astLast, 2, astStmt); .) ]
|
|
|
+ 1947 "END" (. astStmt := astIf;
|
|
|
+ 1948 IF hasElse THEN
|
|
|
+ 1949 QbeGen.EmitLabel(lEnd)
|
|
|
+ 1950 ELSE QbeGen.EmitLabel(lElse);
|
|
|
+ 1951 QbeGen.EmitLabel(lEnd)
|
|
|
+ 1952 END; .) .
|
|
|
+ 1953 WhileStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1954 q, lTop, lBody, lEnd:
|
|
|
+ 1955 QbeGen.QVal;
|
|
|
+ 1956 astCond, astNode: AST.Node; .)
|
|
|
+ 1957 = "WHILE" (. astStmt := AST.NoNode;
|
|
|
+ 1958 QbeGen.NewLabel(lTop);
|
|
|
+ 1959 QbeGen.NewLabel(lBody);
|
|
|
+ 1960 QbeGen.NewLabel(lEnd);
|
|
|
+ 1961 QbeGen.EmitLabel(lTop); .)
|
|
|
+ 1962 Expr<t, q> (. astCond := astCur;
|
|
|
+ 1963 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
+ 1964 SemError(214) END;
|
|
|
+ 1965 QbeGen.Jnz(q, lBody, lEnd);
|
|
|
+ 1966 QbeGen.EmitLabel(lBody); .)
|
|
|
+ 1967 "DO" [ StatSeq ] (. astNode := AST.MakeNode(AST.NkWhile);
|
|
|
+ 1968 AST.SetChild(astNode, 0, astCond);
|
|
|
+ 1969 AST.SetChild(astNode, 1, astStmt);
|
|
|
+ 1970 astStmt := astNode;
|
|
|
+ 1971 QbeGen.Jmp(lTop); .)
|
|
|
+ 1972 "END" (. QbeGen.EmitLabel(lEnd); .) .
|
|
|
+ 1973 RepeatStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1974 q, lTop, lEnd: QbeGen.QVal;
|
|
|
+ 1975 astCond, astBody, astNode:
|
|
|
+ 1976 AST.Node; .)
|
|
|
+ 1977 = "REPEAT" (. astStmt := AST.NoNode;
|
|
|
+ 1978 QbeGen.NewLabel(lTop);
|
|
|
+ 1979 QbeGen.NewLabel(lEnd);
|
|
|
+ 1980 QbeGen.EmitLabel(lTop); .)
|
|
|
+ 1981 [ StatSeq ] (. astBody := astStmt; .)
|
|
|
+ 1982 "UNTIL" Expr<t, q> (. astCond := astCur;
|
|
|
+ 1983 astNode := AST.MakeNode(AST.NkRepeat);
|
|
|
+ 1984 AST.SetChild(astNode, 0, astBody);
|
|
|
+ 1985 AST.SetChild(astNode, 1, astCond);
|
|
|
+ 1986 astStmt := astNode;
|
|
|
+ 1987 IF NOT SymTab.BoolCheck(t) THEN
|
|
|
+ 1988 SemError(214) END;
|
|
|
+ 1989 QbeGen.Jnz(q, lEnd, lTop);
|
|
|
+ 1990 QbeGen.EmitLabel(lEnd); .) .
|
|
|
+ 1991 LoopStat (. VAR lTop, lEnd: QbeGen.QVal; astNode: AST.Node; .)
|
|
|
+ 1992 = "LOOP" (. QbeGen.NewLabel(lTop);
|
|
|
+ 1993 astStmt := AST.NoNode;
|
|
|
+ 1994 QbeGen.NewLabel(lEnd);
|
|
|
+ 1995 QbeGen.PushLoop(lEnd);
|
|
|
+ 1996 QbeGen.EmitLabel(lTop); .)
|
|
|
+ 1997 [ StatSeq ]
|
|
|
+ 1998 "END" (. astNode := AST.MakeNode(AST.NkLoop);
|
|
|
+ 1999 AST.SetChild(astNode, 0, astStmt);
|
|
|
+ 2000 astStmt := astNode;
|
|
|
+ 2001 QbeGen.Jmp(lTop);
|
|
|
+ 2002 QbeGen.PopLoop;
|
|
|
+ 2003 QbeGen.EmitLabel(lEnd); .) .
|
|
|
+ 2004 (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
|
|
|
+ 2005 Runtime direction would need a compare-select; the literal
|
|
|
+ 2006 sign picks cslew/csegew at "DO" time. *)
|
|
|
+ 2007 ForStat (. VAR lv: SymTab.Name;
|
|
|
+ 2008 tlo, thi, tby:
|
|
|
+ 2009 SymTab.TypeIndex;
|
|
|
+ 2010 qlo, qhi, qby, qt, qk, qb:
|
|
|
+ 2011 QbeGen.QVal;
|
|
|
+ 2012 lTop, lBody, lEnd:
|
|
|
+ 2013 QbeGen.QVal;
|
|
|
+ 2014 by: INTEGER;
|
|
|
+ 2015 ok: BOOLEAN;
|
|
|
+ 2016 astVar, astLo, astHi, astBy,
|
|
|
+ 2017 astNode: AST.Node; .)
|
|
|
+ 2018 = "FOR" (. by := 1; .)
|
|
|
+ 2019 GetIdent<lv> (. astVar := AST.MakeLeaf(AST.NkIdent, lv);
|
|
|
+ 2020 astStmt := AST.NoNode;
|
|
|
+ 2021 astBy := AST.NoNode;
|
|
|
+ 2022 ok := SymTab.Lookup(lv);
|
|
|
+ 2023 IF NOT ok THEN
|
|
|
+ 2024 SemError(201)
|
|
|
+ 2025 ELSIF (SymTab.SymKind(lv) #
|
|
|
+ 2026 SymTab.KindVar)
|
|
|
+ 2027 AND (SymTab.SymKind(lv) #
|
|
|
+ 2028 SymTab.KindParam) THEN
|
|
|
+ 2029 SemError(220); ok := FALSE
|
|
|
+ 2030 ELSIF NOT SymTab.IsIntFamily(
|
|
|
+ 2031 SymTab.SymType(lv)) THEN
|
|
|
+ 2032 SemError(220); ok := FALSE
|
|
|
+ 2033 END; .)
|
|
|
+ 2034 ":=" Expr<tlo, qlo> (. astLo := astCur;
|
|
|
+ 2035 IF NOT SymTab.IsIntFamily(tlo) THEN
|
|
|
+ 2036 SemError(220); ok := FALSE
|
|
|
+ 2037 END; .)
|
|
|
+ 2038 "TO" Expr<thi, qhi> (. astHi := astCur;
|
|
|
+ 2039 IF NOT SymTab.IsIntFamily(thi) THEN
|
|
|
+ 2040 SemError(220); ok := FALSE
|
|
|
+ 2041 END; .)
|
|
|
+ 2042 [ "BY" Expr<tby, qby> (. astBy := astCur;
|
|
|
+ 2043 IF (tby #
|
|
|
+ 2044 SymTab.InvalidType)
|
|
|
+ 2045 AND NOT SymTab.IsIntFamily(tby) THEN
|
|
|
+ 2046 SemError(220); ok := FALSE
|
|
|
+ 2047 END;
|
|
|
+ 2048 IF NOT SymTab.ConstInt(qby, by) THEN
|
|
|
+ 2049 SemError(230); by := 1
|
|
|
+ 2050 ELSIF by = 0 THEN
|
|
|
+ 2051 SemError(220); by := 1
|
|
|
+ 2052 END; .) ]
|
|
|
+ 2053 "DO" (. IF ok THEN
|
|
|
+ 2054 QbeGen.StoreVar(lv, qlo,
|
|
|
+ 2055 FALSE) END;
|
|
|
+ 2056 QbeGen.NewLabel(lTop);
|
|
|
+ 2057 QbeGen.NewLabel(lBody);
|
|
|
+ 2058 QbeGen.NewLabel(lEnd);
|
|
|
+ 2059 QbeGen.EmitLabel(lTop);
|
|
|
+ 2060 QbeGen.LoadVar(lv, FALSE, qt);
|
|
|
+ 2061 QbeGen.NewTemp(qk);
|
|
|
+ 2062 IF by > 0 THEN
|
|
|
+ 2063 QbeGen.Op3("cslew", qk,
|
|
|
+ 2064 qt, qhi, FALSE)
|
|
|
+ 2065 ELSE QbeGen.Op3("csgew", qk,
|
|
|
+ 2066 qt, qhi, FALSE)
|
|
|
+ 2067 END;
|
|
|
+ 2068 QbeGen.Jnz(qk, lBody, lEnd);
|
|
|
+ 2069 QbeGen.EmitLabel(lBody); .)
|
|
|
+ 2070 [ StatSeq ]
|
|
|
+ 2071 "END" (. astNode := AST.MakeNode(AST.NkFor);
|
|
|
+ 2072 AST.SetChild(astNode, 0, astVar);
|
|
|
+ 2073 AST.SetChild(astNode, 1, astLo);
|
|
|
+ 2074 AST.SetChild(astNode, 2, astHi);
|
|
|
+ 2075 AST.SetChild(astNode, 3, astBy);
|
|
|
+ 2076 AST.SetChild(astNode, 4, astStmt);
|
|
|
+ 2077 astStmt := astNode;
|
|
|
+ 2078 IF ok THEN
|
|
|
+ 2079 QbeGen.LoadVar(lv, FALSE,
|
|
|
+ 2080 qt);
|
|
|
+ 2081 QbeGen.IntStr(by, qb);
|
|
|
+ 2082 QbeGen.NewTemp(qk);
|
|
|
+ 2083 QbeGen.Op3("add", qk,
|
|
|
+ 2084 qt, qb, FALSE);
|
|
|
+ 2085 QbeGen.StoreVar(lv, qk,
|
|
|
+ 2086 FALSE) END;
|
|
|
+ 2087 QbeGen.Jmp(lTop);
|
|
|
+ 2088 QbeGen.EmitLabel(lEnd); .) .
|
|
|
+ 2089 CaseStat (. VAR tsel: SymTab.TypeIndex;
|
|
|
+ 2090 qsel, lEnd: QbeGen.QVal;
|
|
|
+ 2091 arm, astNode, astArms,
|
|
|
+ 2092 astArmsTail: AST.Node; .)
|
|
|
+ 2093 = "CASE" Expr<tsel, qsel> (. astNode := AST.MakeNode(AST.NkCase);
|
|
|
+ 2094 AST.SetChild(astNode, 0, astCur);
|
|
|
+ 2095 astArms := AST.NoNode;
|
|
|
+ 2096 astArmsTail := AST.NoNode;
|
|
|
+ 2097 QbeGen.NewLabel(lEnd); .)
|
|
|
+ 2098 "OF" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail>
|
|
|
+ 2099 { "|" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail> }
|
|
|
+ 2100 [ "ELSE" (. astStmt := AST.NoNode; .)
|
|
|
+ 2101 [ StatSeq ] (. arm := AST.MakeNode(AST.NkCaseArm);
|
|
|
+ 2102 AST.SetOp(arm, 1);
|
|
|
+ 2103 AST.SetChild(arm, 0, astStmt);
|
|
|
+ 2104 AstAppend(AST.NkBlock,
|
|
|
+ 2105 astArms, astArmsTail, arm); .) ]
|
|
|
+ 2106 "END" (. AST.SetChild(astNode, 1, astArms);
|
|
|
+ 2107 astStmt := astNode;
|
|
|
+ 2108 QbeGen.EmitLabel(lEnd); .) .
|
|
|
+ 2109 (* Compare-chain lowering: each alternative ends its match-tests
|
|
|
+ 2110 with "jmp lAfter", so the no-match fallthrough skips the body:
|
|
|
+ 2111 "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
|
|
|
+ 2112 lAfter:". Falls into the next alternative, ELSE, or END. *)
|
|
|
+ 2113 CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
|
|
|
+ 2114 lEnd: QbeGen.QVal; VAR arms, armsTail: AST.Node>
|
|
|
+ 2115 (. VAR lBody, lAfter: QbeGen.QVal;
|
|
|
+ 2116 arm: AST.Node; .)
|
|
|
+ 2117 = (. arm := AST.MakeNode(AST.NkCaseArm);
|
|
|
+ 2118 QbeGen.NewLabel(lBody);
|
|
|
+ 2119 QbeGen.NewLabel(lAfter); .)
|
|
|
+ 2120 CaseLabel<tsel, qsel, lBody, arm>
|
|
|
+ 2121 { "," CaseLabel<tsel, qsel, lBody, arm> }
|
|
|
+ 2122 ":" (. astStmt := AST.NoNode;
|
|
|
+ 2123 QbeGen.Jmp(lAfter);
|
|
|
+ 2124 QbeGen.EmitLabel(lBody); .)
|
|
|
+ 2125 [ StatSeq ] (. AST.SetChild(arm, AST.NChild(arm),
|
|
|
+ 2126 astStmt);
|
|
|
+ 2127 AstAppend(AST.NkBlock,
|
|
|
+ 2128 arms, armsTail, arm);
|
|
|
+ 2129 QbeGen.Jmp(lEnd);
|
|
|
+ 2130 QbeGen.EmitLabel(lAfter); .) .
|
|
|
+ 2131 CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
|
|
|
+ 2132 lBody: QbeGen.QVal; arm: AST.Node>
|
|
|
+ 2133 (. VAR t2, t3: SymTab.TypeIndex;
|
|
|
+ 2134 q2, q3, qc, qd, qe:
|
|
|
+ 2135 QbeGen.QVal;
|
|
|
+ 2136 astLab: AST.Node;
|
|
|
+ 2137 lNext: QbeGen.QVal; .)
|
|
|
+ 2138 = Expr<t2, q2> (. astLab := astCur;
|
|
|
+ 2139 IF (t2 #
|
|
|
+ 2140 SymTab.InvalidType)
|
|
|
+ 2141 AND (tsel #
|
|
|
+ 2142 SymTab.InvalidType)
|
|
|
+ 2143 AND ((SymTab.ClassOf(t2) =
|
|
|
+ 2144 SymTab.ClSet)
|
|
|
+ 2145 OR (SymTab.ClassOf(tsel) =
|
|
|
+ 2146 SymTab.ClSet)) THEN
|
|
|
+ 2147 SemError(230)
|
|
|
+ 2148 ELSIF (t2 #
|
|
|
+ 2149 SymTab.InvalidType)
|
|
|
+ 2150 AND (tsel #
|
|
|
+ 2151 SymTab.InvalidType)
|
|
|
+ 2152 AND NOT SymTab.EqCheck(t2,
|
|
|
+ 2153 tsel) THEN
|
|
|
+ 2154 SemError(213) END;
|
|
|
+ 2155 IF NOT QbeGen.IsImm(q2) THEN
|
|
|
+ 2156 SemError(230);
|
|
|
+ 2157 QbeGen.CopyOp("0", q2)
|
|
|
+ 2158 END;
|
|
|
+ 2159 QbeGen.NewLabel(lNext);
|
|
|
+ 2160 QbeGen.Cmp(SymTab.OpEq,
|
|
|
+ 2161 qsel, q2, qc, FALSE);
|
|
|
+ 2162 QbeGen.Jnz(qc, lBody, lNext);
|
|
|
+ 2163 QbeGen.EmitLabel(lNext); .)
|
|
|
+ 2164 [ ".." Expr<t3, q3> (. astLab := AST.MakeBin(
|
|
|
+ 2165 AST.NkSubrange, 0, astLab, astCur);
|
|
|
+ 2166 IF (t3 #
|
|
|
+ 2167 SymTab.InvalidType)
|
|
|
+ 2168 AND (tsel #
|
|
|
+ 2169 SymTab.InvalidType)
|
|
|
+ 2170 AND NOT SymTab.EqCheck(t3,
|
|
|
+ 2171 tsel) THEN
|
|
|
+ 2172 SemError(213) END;
|
|
|
+ 2173 IF NOT QbeGen.IsImm(q3) THEN
|
|
|
+ 2174 SemError(230);
|
|
|
+ 2175 QbeGen.CopyOp("0", q3)
|
|
|
+ 2176 END;
|
|
|
+ 2177 QbeGen.Cmp(SymTab.OpGe,
|
|
|
+ 2178 qsel, q2, qc, FALSE);
|
|
|
+ 2179 QbeGen.Cmp(SymTab.OpLe,
|
|
|
+ 2180 qsel, q3, qd, FALSE);
|
|
|
+ 2181 QbeGen.NewTemp(qe);
|
|
|
+ 2182 QbeGen.Op3("and", qe, qc, qd,
|
|
|
+ 2183 FALSE);
|
|
|
+ 2184 QbeGen.NewLabel(lNext);
|
|
|
+ 2185 QbeGen.Jnz(qe, lBody, lNext);
|
|
|
+ 2186 QbeGen.EmitLabel(lNext); .) ]
|
|
|
+ 2187 (. AST.SetChild(arm,
|
|
|
+ 2188 AST.NChild(arm), astLab); .) .
|
|
|
+ 2189 ReturnStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 2190 q, qt: QbeGen.QVal;
|
|
|
+ 2191 res: SymTab.TypeIndex;
|
|
|
+ 2192 hadE, conv: BOOLEAN;
|
|
|
+ 2193 astVal, astNode: AST.Node; .)
|
|
|
+ 2194 = "RETURN" (. hadE := FALSE; astStmt := AST.NoNode; .)
|
|
|
+ 2195 [ Expr<t, q> (. hadE := TRUE; astVal := astCur; .) ]
|
|
|
+ 2196 (. astNode := AST.MakeNode(AST.NkReturn);
|
|
|
+ 2197 IF hadE THEN
|
|
|
+ 2198 AST.SetChild(astNode, 0, astVal)
|
|
|
+ 2199 END;
|
|
|
+ 2200 astStmt := astNode;
|
|
|
+ 2201 conv := FALSE;
|
|
|
+ 2202 IF NOT SymTab.InProc() THEN
|
|
|
+ 2203 SemError(232)
|
|
|
+ 2204 ELSE res := SymTab.CurRes();
|
|
|
+ 2205 IF NOT hadE THEN
|
|
|
+ 2206 IF res #
|
|
|
+ 2207 SymTab.InvalidType THEN
|
|
|
+ 2208 SemError(232)
|
|
|
+ 2209 ELSE QbeGen.EmitRet(q,
|
|
|
+ 2210 FALSE)
|
|
|
+ 2211 END
|
|
|
+ 2212 ELSIF (res =
|
|
|
+ 2213 SymTab.InvalidType)
|
|
|
+ 2214 OR (t #
|
|
|
+ 2215 SymTab.InvalidType)
|
|
|
+ 2216 AND NOT SymTab.Assignable(t,
|
|
|
+ 2217 res) THEN
|
|
|
+ 2218 SemError(232)
|
|
|
+ 2219 ELSE
|
|
|
+ 2220 conv := (SymTab.ClassOf(
|
|
|
+ 2221 res) = SymTab.ClReal)
|
|
|
+ 2222 AND SymTab.IsIntFamily(t);
|
|
|
+ 2223 IF conv THEN
|
|
|
+ 2224 QbeGen.ConvIR(q, qt);
|
|
|
+ 2225 QbeGen.EmitRet(qt, TRUE)
|
|
|
+ 2226 ELSE QbeGen.EmitRet(q, TRUE)
|
|
|
+ 2227 END
|
|
|
+ 2228 END
|
|
|
+ 2229 END; .) .
|
|
|
+ 2230 HaltStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 2231 q: QbeGen.QVal;
|
|
|
+ 2232 astVal, astNode: AST.Node; .)
|
|
|
+ 2233 = "HALT" (. astVal := AST.NoNode; .)
|
|
|
+ 2234 [ "(" Expr<t, q> (. astVal := astCur; .) ")" ]
|
|
|
+ 2235 (. astNode := AST.MakeNode(AST.NkHalt);
|
|
|
+ 2236 IF astVal # AST.NoNode THEN
|
|
|
+ 2237 AST.SetChild(astNode, 0, astVal)
|
|
|
+ 2238 END;
|
|
|
+ 2239 astStmt := astNode;
|
|
|
+ 2240 QbeGen.HaltQ; .) .
|
|
|
+ 2241 (* Designator: scalar loads, array addresses, and index suffixes.
|
|
|
+ 2242 Each index descends one level (bounds-checked, trap on breach);
|
|
|
+ 2243 nested levels reload the inner descriptor address. q ends as the
|
|
|
+ 2244 value (scalars), the descriptor address (plain arrays), or the
|
|
|
+ 2245 element address (indexed); sfx marks the indexed form. *)
|
|
|
+ 2246 Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
|
|
|
+ 2247 VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
|
|
|
+ 2248 (. VAR n, fn, mal: SymTab.Name;
|
|
|
+ 2249 cls: INTEGER;
|
|
|
+ 2250 ic: SymTab.TypeIndex;
|
|
|
+ 2251 curT, it, eT, bt:
|
|
|
+ 2252 SymTab.TypeIndex;
|
|
|
+ 2253 iq, ql, qlo, qhi, qe:
|
|
|
+ 2254 QbeGen.QVal;
|
|
|
+ 2255 lo, hi: INTEGER;
|
|
|
+ 2256 fo: INTEGER;
|
|
|
+ 2257 isOpen: BOOLEAN;
|
|
|
+ 2258 qb, cv: QbeGen.QVal;
|
|
|
+ 2259 fid, fref, slot: INTEGER;
|
|
|
+ 2260 r: BOOLEAN;
|
|
|
+ 2261 astDes, astSel: AST.Node; .)
|
|
|
+ 2262 = GetIdent<n> (. methCls := SymTab.InvalidType;
|
|
|
+ 2263 QbeGen.CopyOp(n, qn);
|
|
|
+ 2264 sfx := FALSE;
|
|
|
+ 2265 fid := 0; fref := 0; slot := 0;
|
|
|
+ 2266 IF NOT SymTab.Lookup(n) THEN
|
|
|
+ 2267 (* a bare method name inside
|
|
|
+ 2268 a CLASS IMPLEMENTATION
|
|
|
+ 2269 is a sibling call on
|
|
|
+ 2270 THIS *)
|
|
|
+ 2271 ic := SymTab.CurImplClass();
|
|
|
+ 2272 IF (ic #
|
|
|
+ 2273 SymTab.InvalidType)
|
|
|
+ 2274 AND SymTab.MethodExists(ic, n) THEN
|
|
|
+ 2275 sfx := FALSE;
|
|
|
+ 2276 QbeGen.ThisBase(q);
|
|
|
+ 2277 QbeGen.ArmRecv(q);
|
|
|
+ 2278 methCls := ic;
|
|
|
+ 2279 k := SymTab.KindProc;
|
|
|
+ 2280 t := SymTab.InvalidType
|
|
|
+ 2281 ELSIF SymTab.InProc() THEN
|
|
|
+ 2282 (* not declared yet: a
|
|
|
+ 2283 forward reference to a
|
|
|
+ 2284 module-level variable
|
|
|
+ 2285 declared further down. *)
|
|
|
+ 2286 k := SymTab.KindVar;
|
|
|
+ 2287 r := SymTab.FwdVarRef(n, k,
|
|
|
+ 2288 fref, t);
|
|
|
+ 2289 slot := QbeGen.FwdDesignator();
|
|
|
+ 2290 FwdVarNote(fref, slot);
|
|
|
+ 2291 fid := slot;
|
|
|
+ 2292 QbeGen.FwdAddrOper(fid, q);
|
|
|
+ 2293 sfx := TRUE
|
|
|
+ 2294 ELSE
|
|
|
+ 2295 SemError(201);
|
|
|
+ 2296 t :=
|
|
|
+ 2297 SymTab.InvalidType;
|
|
|
+ 2298 k := -1;
|
|
|
+ 2299 QbeGen.CopyOp("0", q)
|
|
|
+ 2300 END
|
|
|
+ 2301 ELSE
|
|
|
+ 2302 t := SymTab.SymType(n);
|
|
|
+ 2303 k := SymTab.SymKind(n);
|
|
|
+ 2304 IF k = SymTab.KindConst THEN
|
|
|
+ 2305 IF SymTab.Equal(n,
|
|
|
+ 2306 "TRUE") THEN
|
|
|
+ 2307 t := SymTab.BoolType();
|
|
|
+ 2308 QbeGen.CopyOp("1", q)
|
|
|
+ 2309 ELSIF SymTab.Equal(n,
|
|
|
+ 2310 "FALSE") THEN
|
|
|
+ 2311 t := SymTab.BoolType();
|
|
|
+ 2312 QbeGen.CopyOp("0", q)
|
|
|
+ 2313 ELSIF SymTab.Equal(n,
|
|
|
+ 2314 "NIL") THEN
|
|
|
+ 2315 QbeGen.CopyOp("0", q)
|
|
|
+ 2316 ELSE
|
|
|
+ 2317 cls :=
|
|
|
+ 2318 SymTab.ClassOf(t);
|
|
|
+ 2319 IF (t #
|
|
|
+ 2320 SymTab.InvalidType)
|
|
|
+ 2321 AND ((cls = SymTab.ClInt)
|
|
|
+ 2322 OR (cls
|
|
|
+ 2323 = SymTab.ClChar)
|
|
|
+ 2324 OR (cls
|
|
|
+ 2325 = SymTab.ClEnum)
|
|
|
+ 2326 OR (cls
|
|
|
+ 2327 = SymTab.ClReal)
|
|
|
+ 2328 OR (cls
|
|
|
+ 2329 = SymTab.ClLong)
|
|
|
+ 2330 OR (cls
|
|
|
+ 2331 = SymTab.ClNil)) THEN
|
|
|
+ 2332 IF cls = SymTab.ClNil THEN
|
|
|
+ 2333 QbeGen.CopyOp("0", q)
|
|
|
+ 2334 ELSIF ((cls
|
|
|
+ 2335 = SymTab.ClInt)
|
|
|
+ 2336 OR (cls
|
|
|
+ 2337 = SymTab.ClChar)
|
|
|
+ 2338 OR (cls
|
|
|
+ 2339 = SymTab.ClEnum)
|
|
|
+ 2340 OR (cls
|
|
|
+ 2341 = SymTab.ClLong))
|
|
|
+ 2342 AND SymTab.GetSymVal(n, cv)
|
|
|
+ 2343 AND QbeGen.IsImm(cv) THEN
|
|
|
+ 2344 QbeGen.CopyOp(cv, q)
|
|
|
+ 2345 ELSE
|
|
|
+ 2346 QbeGen.LoadVar(n,
|
|
|
+ 2347 cls = SymTab.ClReal,
|
|
|
+ 2348 q)
|
|
|
+ 2349 END
|
|
|
+ 2350 ELSIF (cls = SymTab.ClArray)
|
|
|
+ 2351 OR (cls = SymTab.ClRecord)
|
|
|
+ 2352 OR (cls = SymTab.ClClass)
|
|
|
+ 2353 OR (cls = SymTab.ClStr)
|
|
|
+ 2354 OR (cls = SymTab.ClUStr) THEN
|
|
|
+ 2355 (* aggregate constant:
|
|
|
+ 2356 its value IS the
|
|
|
+ 2357 descriptor address *)
|
|
|
+ 2358 IF SymTab.GetSymVal(n, cv) THEN
|
|
|
+ 2359 QbeGen.CopyOp(cv, q)
|
|
|
+ 2360 ELSE
|
|
|
+ 2361 QbeGen.CopyOp("0", q)
|
|
|
+ 2362 END
|
|
|
+ 2363 ELSE
|
|
|
+ 2364 IF t #
|
|
|
+ 2365 SymTab.InvalidType THEN
|
|
|
+ 2366 SemError(230)
|
|
|
+ 2367 END;
|
|
|
+ 2368 QbeGen.CopyOp("0", q)
|
|
|
+ 2369 END
|
|
|
+ 2370 END
|
|
|
+ 2371 ELSIF (k = SymTab.KindVar)
|
|
|
+ 2372 OR (k = SymTab.KindParam) THEN
|
|
|
+ 2373 cls :=
|
|
|
+ 2374 SymTab.ClassOf(t);
|
|
|
+ 2375 IF (cls = SymTab.ClInt)
|
|
|
+ 2376 OR (cls = SymTab.ClBool)
|
|
|
+ 2377 OR (cls = SymTab.ClChar)
|
|
|
+ 2378 OR (cls = SymTab.ClUChar)
|
|
|
+ 2379 OR (cls = SymTab.ClEnum)
|
|
|
+ 2380 OR (cls
|
|
|
+ 2381 = SymTab.ClReal) THEN
|
|
|
+ 2382 QbeGen.LoadVar(n,
|
|
|
+ 2383 cls = SymTab.ClReal, q)
|
|
|
+ 2384 ELSIF (cls = SymTab.ClPtr)
|
|
|
+ 2385 OR (cls = SymTab.ClProc) THEN
|
|
|
+ 2386 QbeGen.LoadPtr(n, q)
|
|
|
+ 2387 ELSIF cls = SymTab.ClLong THEN
|
|
|
+ 2388 QbeGen.LoadLong(n, q)
|
|
|
+ 2389 ELSIF (cls
|
|
|
+ 2390 = SymTab.ClArray)
|
|
|
+ 2391 OR (cls
|
|
|
+ 2392 = SymTab.ClSet)
|
|
|
+ 2393 OR (cls
|
|
|
+ 2394 = SymTab.ClRecord)
|
|
|
+ 2395 OR (cls
|
|
|
+ 2396 = SymTab.ClUStr)
|
|
|
+ 2397 OR (cls
|
|
|
+ 2398 = SymTab.ClClass) THEN
|
|
|
+ 2399 QbeGen.AddrOf(n, q)
|
|
|
+ 2400 ELSE SemError(230);
|
|
|
+ 2401 QbeGen.CopyOp("0", q)
|
|
|
+ 2402 END
|
|
|
+ 2403 ELSE QbeGen.CopyOp("0", q);
|
|
|
+ 2404 IF k = SymTab.KindImport THEN
|
|
|
+ 2405 SemError(230)
|
|
|
+ 2406 ELSIF k =
|
|
|
+ 2407 SymTab.KindProc THEN
|
|
|
+ 2408 (* bare procedure name:
|
|
|
+ 2409 a following ArgList
|
|
|
+ 2410 makes it a call;
|
|
|
+ 2411 otherwise Fact
|
|
|
+ 2412 reports 230 *)
|
|
|
+ 2413 ELSE
|
|
|
+ 2414 IF k = SymTab.KindField THEN
|
|
|
+ 2415 IF QbeGen.TopWith(qb) THEN
|
|
|
+ 2416 fo :=
|
|
|
+ 2417 SymTab.FieldOffset(
|
|
|
+ 2418 SymTab.FieldOwner(n),
|
|
|
+ 2419 n);
|
|
|
+ 2420 QbeGen.FieldAddr(qb,
|
|
|
+ 2421 fo, q);
|
|
|
+ 2422 sfx := TRUE
|
|
|
+ 2423 ELSE SemError(230);
|
|
|
+ 2424 QbeGen.CopyOp("0", q)
|
|
|
+ 2425 END
|
|
|
+ 2426 END
|
|
|
+ 2427 END
|
|
|
+ 2428 END
|
|
|
+ 2429 END; .)
|
|
|
+ 2430 (. astDes := AST.MakeNode(AST.NkDesignator);
|
|
|
+ 2431 AST.SetChild(astDes, AST.NChild(astDes), AST.MakeLeaf(AST.NkIdent, n)); .)
|
|
|
+ 2432 { "[" Expr<it, iq>
|
|
|
+ 2433 (. AST.SetChild(astDes, AST.NChild(astDes),
|
|
|
+ 2434 AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
+ 2435 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 2436 SymTab.ClArray THEN
|
|
|
+ 2437 SemError(217);
|
|
|
+ 2438 t := SymTab.InvalidType
|
|
|
+ 2439 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
+ 2440 AND (SymTab.ClassOf(it) #
|
|
|
+ 2441 SymTab.ClChar)
|
|
|
+ 2442 AND (SymTab.ClassOf(it) #
|
|
|
+ 2443 SymTab.ClEnum) THEN
|
|
|
+ 2444 SemError(218);
|
|
|
+ 2445 t := SymTab.InvalidType
|
|
|
+ 2446 ELSE
|
|
|
+ 2447 QbeGen.WidenIndex(iq, ql);
|
|
|
+ 2448 isOpen :=
|
|
|
+ 2449 SymTab.IsOpenArray(t);
|
|
|
+ 2450 IF isOpen THEN
|
|
|
+ 2451 QbeGen.CopyOp("0", qlo);
|
|
|
+ 2452 IF SymTab.IsCharArray(t)
|
|
|
+ 2453 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2454 QbeGen.OpenHiChar(q, qhi)
|
|
|
+ 2455 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
+ 2456 END
|
|
|
+ 2457 ELSE
|
|
|
+ 2458 lo := SymTab.ArrayLo(t);
|
|
|
+ 2459 hi := SymTab.ArrayHi(t);
|
|
|
+ 2460 IF SymTab.IsCharArray(t)
|
|
|
+ 2461 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2462 hi := hi + 1
|
|
|
+ 2463 END;
|
|
|
+ 2464 QbeGen.IntStr(lo, qlo);
|
|
|
+ 2465 QbeGen.IntStr(hi, qhi)
|
|
|
+ 2466 END;
|
|
|
+ 2467 QbeGen.CheckRange(ql, qlo,
|
|
|
+ 2468 qhi);
|
|
|
+ 2469 eT := SymTab.ArrayElem(t);
|
|
|
+ 2470 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
+ 2471 t, qe);
|
|
|
+ 2472 IF SymTab.ClassOf(eT) =
|
|
|
+ 2473 SymTab.ClArray THEN
|
|
|
+ 2474 QbeGen.ElemLoad(qe, eT, q)
|
|
|
+ 2475 ELSE QbeGen.CopyOp(qe, q)
|
|
|
+ 2476 END;
|
|
|
+ 2477 t := eT; sfx := TRUE
|
|
|
+ 2478 END; .)
|
|
|
+ 2479 { "," Expr<it, iq>
|
|
|
+ 2480 (. AST.SetChild(astDes, AST.NChild(astDes),
|
|
|
+ 2481 AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
+ 2482 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 2483 SymTab.ClArray THEN
|
|
|
+ 2484 SemError(217);
|
|
|
+ 2485 t := SymTab.InvalidType
|
|
|
+ 2486 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
+ 2487 AND (SymTab.ClassOf(it) #
|
|
|
+ 2488 SymTab.ClChar)
|
|
|
+ 2489 AND (SymTab.ClassOf(it) #
|
|
|
+ 2490 SymTab.ClEnum) THEN
|
|
|
+ 2491 SemError(218);
|
|
|
+ 2492 t := SymTab.InvalidType
|
|
|
+ 2493 ELSE
|
|
|
+ 2494 QbeGen.WidenIndex(iq, ql);
|
|
|
+ 2495 isOpen :=
|
|
|
+ 2496 SymTab.IsOpenArray(t);
|
|
|
+ 2497 IF isOpen THEN
|
|
|
+ 2498 QbeGen.CopyOp("0", qlo);
|
|
|
+ 2499 IF SymTab.IsCharArray(t)
|
|
|
+ 2500 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2501 QbeGen.OpenHiChar(q, qhi)
|
|
|
+ 2502 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
+ 2503 END
|
|
|
+ 2504 ELSE
|
|
|
+ 2505 lo := SymTab.ArrayLo(t);
|
|
|
+ 2506 hi := SymTab.ArrayHi(t);
|
|
|
+ 2507 IF SymTab.IsCharArray(t)
|
|
|
+ 2508 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2509 hi := hi + 1
|
|
|
+ 2510 END;
|
|
|
+ 2511 QbeGen.IntStr(lo, qlo);
|
|
|
+ 2512 QbeGen.IntStr(hi, qhi)
|
|
|
+ 2513 END;
|
|
|
+ 2514 QbeGen.CheckRange(ql, qlo,
|
|
|
+ 2515 qhi);
|
|
|
+ 2516 eT := SymTab.ArrayElem(t);
|
|
|
+ 2517 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
+ 2518 t, qe);
|
|
|
+ 2519 IF SymTab.ClassOf(eT) =
|
|
|
+ 2520 SymTab.ClArray THEN
|
|
|
+ 2521 QbeGen.ElemLoad(qe, eT, q)
|
|
|
+ 2522 ELSE QbeGen.CopyOp(qe, q)
|
|
|
+ 2523 END;
|
|
|
+ 2524 t := eT; sfx := TRUE
|
|
|
+ 2525 END; .) }
|
|
|
+ 2526 "]"
|
|
|
+ 2527 | "." GetIdent<fn>
|
|
|
+ 2528 (. astSel := AST.MakeNode(AST.NkSelector);
|
|
|
+ 2529 AST.SetOp(astSel, AST.SelField);
|
|
|
+ 2530 AST.SetChild(astSel, 0, AST.MakeLeaf(AST.NkIdent, fn));
|
|
|
+ 2531 AST.SetChild(astDes, AST.NChild(astDes), astSel); IF k = SymTab.KindModule THEN
|
|
|
+ 2532 (* qualified L.x: materialize
|
|
|
+ 2533 the export, then load it *)
|
|
|
+ 2534 IF NOT SymTab.MaterializeAlias(n,
|
|
|
+ 2535 fn, mal) THEN
|
|
|
+ 2536 SemError(201);
|
|
|
+ 2537 t := SymTab.InvalidType;
|
|
|
+ 2538 QbeGen.CopyOp("0", q)
|
|
|
+ 2539 ELSE
|
|
|
+ 2540 QbeGen.CopyOp(mal, qn);
|
|
|
+ 2541 t := SymTab.SymType(mal);
|
|
|
+ 2542 k := SymTab.SymKind(mal);
|
|
|
+ 2543 sfx := FALSE;
|
|
|
+ 2544 IF k = SymTab.KindProc THEN
|
|
|
+ 2545 (* call: ArgList supplies
|
|
|
+ 2546 the value *)
|
|
|
+ 2547 QbeGen.CopyOp("0", q)
|
|
|
+ 2548 ELSIF NOT QbeGen.LoadDesignator(
|
|
|
+ 2549 mal, t, k, q) THEN
|
|
|
+ 2550 SemError(230);
|
|
|
+ 2551 QbeGen.CopyOp("0", q)
|
|
|
+ 2552 END
|
|
|
+ 2553 END
|
|
|
+ 2554 ELSIF t = SymTab.InvalidType THEN
|
|
|
+ 2555 ELSIF (SymTab.ClassOf(t) #
|
|
|
+ 2556 SymTab.ClRecord)
|
|
|
+ 2557 AND (SymTab.ClassOf(t) #
|
|
|
+ 2558 SymTab.ClClass) THEN
|
|
|
+ 2559 SemError(215);
|
|
|
+ 2560 t := SymTab.InvalidType
|
|
|
+ 2561 ELSIF (SymTab.ClassOf(t) =
|
|
|
+ 2562 SymTab.ClClass)
|
|
|
+ 2563 AND SymTab.MethodExists(t, fn) THEN
|
|
|
+ 2564 (* obj.Method: bind the
|
|
|
+ 2565 method and pass obj as
|
|
|
+ 2566 the hidden receiver; q
|
|
|
+ 2567 already holds the
|
|
|
+ 2568 object's address *)
|
|
|
+ 2569 QbeGen.ArmRecv(q);
|
|
|
+ 2570 QbeGen.CopyOp(fn, n);
|
|
|
+ 2571 QbeGen.CopyOp(fn, qn);
|
|
|
+ 2572 methCls := t;
|
|
|
+ 2573 k := SymTab.KindProc;
|
|
|
+ 2574 t := SymTab.InvalidType
|
|
|
+ 2575 ELSIF NOT SymTab.FieldExists(t,
|
|
|
+ 2576 fn) THEN
|
|
|
+ 2577 SemError(216);
|
|
|
+ 2578 t := SymTab.InvalidType
|
|
|
+ 2579 ELSE
|
|
|
+ 2580 fo := SymTab.FieldOffset(t,
|
|
|
+ 2581 fn);
|
|
|
+ 2582 t := SymTab.FieldType(t, fn);
|
|
|
+ 2583 QbeGen.FieldAddr(q, fo, qe);
|
|
|
+ 2584 (* array fields are inline:
|
|
|
+ 2585 the field address is the
|
|
|
+ 2586 descriptor, like records *)
|
|
|
+ 2587 QbeGen.CopyOp(qe, q);
|
|
|
+ 2588 sfx := TRUE
|
|
|
+ 2589 END; .)
|
|
|
+ 2590 | "^"
|
|
|
+ 2591 (. astSel := AST.MakeNode(AST.NkSelector);
|
|
|
+ 2592 AST.SetOp(astSel, AST.SelDeref);
|
|
|
+ 2593 AST.SetChild(astDes, AST.NChild(astDes), astSel); IF t = SymTab.InvalidType THEN
|
|
|
+ 2594 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 2595 SymTab.ClPtr THEN
|
|
|
+ 2596 SemError(219);
|
|
|
+ 2597 t := SymTab.InvalidType
|
|
|
+ 2598 ELSE
|
|
|
+ 2599 bt := SymTab.PtrBase(t);
|
|
|
+ 2600 IF bt = SymTab.InvalidType THEN
|
|
|
+ 2601 ELSE
|
|
|
+ 2602 IF sfx THEN
|
|
|
+ 2603 QbeGen.ElemLoad(q, t,
|
|
|
+ 2604 qb);
|
|
|
+ 2605 QbeGen.CopyOp(qb, q)
|
|
|
+ 2606 END;
|
|
|
+ 2607 t := bt;
|
|
|
+ 2608 (* q holds the pointee
|
|
|
+ 2609 address: Fact loads
|
|
|
+ 2610 scalars/pointers and uses
|
|
|
+ 2611 the address for
|
|
|
+ 2612 aggregates; the VAR-actual
|
|
|
+ 2613 note is q itself. *)
|
|
|
+ 2614 sfx := TRUE
|
|
|
+ 2615 END
|
|
|
+ 2616 END; .) } (. astCur := astDes; .) .
|
|
|
+ 2617 (* Result suffix (ISO component after a function call): `F()^`,
|
|
|
+ 2618 `F()[i]`, `F().field`. The call result is in t/q with sfx FALSE
|
|
|
+ 2619 (a value, or a descriptor address for aggregates); each component
|
|
|
+ 2620 descends one level exactly like the Design components. *)
|
|
|
+ 2621 ResultComp<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
|
|
|
+ 2622 VAR sfx: BOOLEAN; VAR node: AST.Node> (. VAR it, eT, bt: SymTab.TypeIndex;
|
|
|
+ 2623 iq, ql, qlo, qhi, qe, qb:
|
|
|
+ 2624 QbeGen.QVal;
|
|
|
+ 2625 lo, hi, fo: INTEGER;
|
|
|
+ 2626 isOpen: BOOLEAN;
|
|
|
+ 2627 fname: SymTab.Name;
|
|
|
+ 2628 astWrap, astSel: AST.Node; .)
|
|
|
+ 2629 = "[" Expr<it, iq>
|
|
|
+ 2630 (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
+ 2631 astWrap := AST.MakeNode(
|
|
|
+ 2632 AST.NkDesignator);
|
|
|
+ 2633 AST.SetChild(astWrap, 0, node);
|
|
|
+ 2634 node := astWrap
|
|
|
+ 2635 END;
|
|
|
+ 2636 AST.SetChild(node, AST.NChild(node),
|
|
|
+ 2637 AST.MakeUn(AST.NkSelector,
|
|
|
+ 2638 AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
|
|
|
+ 2639 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 2640 SymTab.ClArray THEN
|
|
|
+ 2641 SemError(217);
|
|
|
+ 2642 t := SymTab.InvalidType
|
|
|
+ 2643 ELSIF NOT SymTab.IsIntFamily(it)
|
|
|
+ 2644 AND (SymTab.ClassOf(it) # SymTab.ClChar)
|
|
|
+ 2645 AND (SymTab.ClassOf(it) # SymTab.ClEnum) THEN
|
|
|
+ 2646 SemError(218);
|
|
|
+ 2647 t := SymTab.InvalidType
|
|
|
+ 2648 ELSE
|
|
|
+ 2649 QbeGen.WidenIndex(iq, ql);
|
|
|
+ 2650 isOpen :=
|
|
|
+ 2651 SymTab.IsOpenArray(t);
|
|
|
+ 2652 IF isOpen THEN
|
|
|
+ 2653 QbeGen.CopyOp("0", qlo);
|
|
|
+ 2654 IF SymTab.IsCharArray(t)
|
|
|
+ 2655 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2656 QbeGen.OpenHiChar(q, qhi)
|
|
|
+ 2657 ELSE QbeGen.OpenHi(q, qhi)
|
|
|
+ 2658 END
|
|
|
+ 2659 ELSE
|
|
|
+ 2660 lo := SymTab.ArrayLo(t);
|
|
|
+ 2661 hi := SymTab.ArrayHi(t);
|
|
|
+ 2662 IF SymTab.IsCharArray(t)
|
|
|
+ 2663 OR SymTab.IsUCharArray(t) THEN
|
|
|
+ 2664 hi := hi + 1
|
|
|
+ 2665 END;
|
|
|
+ 2666 QbeGen.IntStr(lo, qlo);
|
|
|
+ 2667 QbeGen.IntStr(hi, qhi)
|
|
|
+ 2668 END;
|
|
|
+ 2669 QbeGen.CheckRange(ql, qlo,
|
|
|
+ 2670 qhi);
|
|
|
+ 2671 eT := SymTab.ArrayElem(t);
|
|
|
+ 2672 QbeGen.ElemAddr(q, ql, qlo,
|
|
|
+ 2673 t, qe);
|
|
|
+ 2674 IF SymTab.ClassOf(eT) =
|
|
|
+ 2675 SymTab.ClArray THEN
|
|
|
+ 2676 QbeGen.ElemLoad(qe, eT, q)
|
|
|
+ 2677 ELSE QbeGen.CopyOp(qe, q)
|
|
|
+ 2678 END;
|
|
|
+ 2679 t := eT; sfx := TRUE
|
|
|
+ 2680 END; .)
|
|
|
+ 2681 "]"
|
|
|
+ 2682 | "." GetIdent<fname>
|
|
|
+ 2683 (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
+ 2684 astWrap := AST.MakeNode(
|
|
|
+ 2685 AST.NkDesignator);
|
|
|
+ 2686 AST.SetChild(astWrap, 0, node);
|
|
|
+ 2687 node := astWrap
|
|
|
+ 2688 END;
|
|
|
+ 2689 AST.SetChild(node, AST.NChild(node),
|
|
|
+ 2690 AST.MakeUn(AST.NkSelector,
|
|
|
+ 2691 AST.SelField,
|
|
|
+ 2692 AST.MakeLeaf(AST.NkIdent,
|
|
|
+ 2693 fname))); IF t = SymTab.InvalidType THEN
|
|
|
+ 2694 ELSIF (SymTab.ClassOf(t) #
|
|
|
+ 2695 SymTab.ClRecord)
|
|
|
+ 2696 AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
|
|
|
+ 2697 SemError(215);
|
|
|
+ 2698 t := SymTab.InvalidType
|
|
|
+ 2699 ELSIF NOT SymTab.FieldExists(t,
|
|
|
+ 2700 fname) THEN
|
|
|
+ 2701 SemError(216);
|
|
|
+ 2702 t := SymTab.InvalidType
|
|
|
+ 2703 ELSE
|
|
|
+ 2704 fo := SymTab.FieldOffset(t,
|
|
|
+ 2705 fname);
|
|
|
+ 2706 t := SymTab.FieldType(t, fname);
|
|
|
+ 2707 QbeGen.FieldAddr(q, fo, qe);
|
|
|
+ 2708 QbeGen.CopyOp(qe, q);
|
|
|
+ 2709 sfx := TRUE
|
|
|
+ 2710 END; .)
|
|
|
+ 2711 | "^" (. IF AST.Kind(node) # AST.NkDesignator THEN
|
|
|
+ 2712 astWrap := AST.MakeNode(
|
|
|
+ 2713 AST.NkDesignator);
|
|
|
+ 2714 AST.SetChild(astWrap, 0, node);
|
|
|
+ 2715 node := astWrap
|
|
|
+ 2716 END;
|
|
|
+ 2717 astSel := AST.MakeNode(AST.NkSelector);
|
|
|
+ 2718 AST.SetOp(astSel, AST.SelDeref);
|
|
|
+ 2719 AST.SetChild(node,
|
|
|
+ 2720 AST.NChild(node), astSel); IF t = SymTab.InvalidType THEN
|
|
|
+ 2721 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 2722 SymTab.ClPtr THEN
|
|
|
+ 2723 SemError(219);
|
|
|
+ 2724 t := SymTab.InvalidType
|
|
|
+ 2725 ELSE
|
|
|
+ 2726 bt := SymTab.PtrBase(t);
|
|
|
+ 2727 IF bt # SymTab.InvalidType THEN
|
|
|
+ 2728 IF sfx THEN
|
|
|
+ 2729 QbeGen.ElemLoad(q, t, qb);
|
|
|
+ 2730 QbeGen.CopyOp(qb, q)
|
|
|
+ 2731 END;
|
|
|
+ 2732 t := bt; sfx := TRUE
|
|
|
+ 2733 END
|
|
|
+ 2734 END; .) .
|
|
|
+ 2735 Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 2736 (. VAR t2: SymTab.TypeIndex;
|
|
|
+ 2737 op: INTEGER;
|
|
|
+ 2738 q2, qt, wl: QbeGen.QVal;
|
|
|
+ 2739 astA, astB: AST.Node;
|
|
|
+ 2740 astOp: INTEGER;
|
|
|
+ 2741 astMade: BOOLEAN;
|
|
|
+ 2742 isR: BOOLEAN; .)
|
|
|
+ 2743 = SimExpr<t, q> (. astA := astCur; astMade := FALSE; .)
|
|
|
+ 2744 [ Rel<op> SimExpr<t2, q2>
|
|
|
+ 2745 (. astB := astCur; astMade := TRUE;
|
|
|
+ 2746 astOp := AST.OpEq;
|
|
|
+ 2747 IF op = SymTab.OpNeq1 THEN astOp := AST.OpNe
|
|
|
+ 2748 ELSIF op = SymTab.OpNeq2 THEN astOp := AST.OpNe
|
|
|
+ 2749 ELSIF op = SymTab.OpLt THEN astOp := AST.OpLt
|
|
|
+ 2750 ELSIF op = SymTab.OpLe THEN astOp := AST.OpLe
|
|
|
+ 2751 ELSIF op = SymTab.OpGt THEN astOp := AST.OpGt
|
|
|
+ 2752 ELSIF op = SymTab.OpGe THEN astOp := AST.OpGe
|
|
|
+ 2753 ELSIF op = SymTab.OpIn THEN astOp := AST.OpIn
|
|
|
+ 2754 END;
|
|
|
+ 2755 IF op = SymTab.OpIn THEN
|
|
|
+ 2756 IF SymTab.InCheck(t, t2) THEN
|
|
|
+ 2757 IF (t = SymTab.InvalidType)
|
|
|
+ 2758 OR (t2 = SymTab.InvalidType) THEN
|
|
|
+ 2759 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
+ 2760 ELSE
|
|
|
+ 2761 QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
|
|
|
+ 2762 SymTab.SetCount(t2), qt);
|
|
|
+ 2763 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2764 END
|
|
|
+ 2765 ELSE SemError(222); t := SymTab.InvalidType;
|
|
|
+ 2766 QbeGen.CopyOp("0", q)
|
|
|
+ 2767 END
|
|
|
+ 2768 ELSIF SymTab.RelCheck(t, t2, op) THEN
|
|
|
+ 2769 IF (t = SymTab.InvalidType)
|
|
|
+ 2770 OR (t2 = SymTab.InvalidType) THEN
|
|
|
+ 2771 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
|
|
|
+ 2772 ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
|
|
|
+ 2773 OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
|
|
|
+ 2774 IF SymTab.IsFwdVar(t) OR SymTab.IsFwdVar(t2) THEN
|
|
|
+ 2775 QbeGen.Cmp(op, q, q2, qt, FALSE);
|
|
|
+ 2776 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2777 ELSIF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
|
|
|
+ 2778 AND (op # SymTab.OpNeq2) THEN
|
|
|
+ 2779 SemError(213); t := SymTab.InvalidType;
|
|
|
+ 2780 QbeGen.CopyOp("0", q)
|
|
|
+ 2781 ELSE
|
|
|
+ 2782 QbeGen.CmpL(op, q, q2, qt);
|
|
|
+ 2783 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2784 END
|
|
|
+ 2785 ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 2786 OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 2787 QbeGen.CmpSet(op, q, q2,
|
|
|
+ 2788 SymTab.SetWords(t), SymTab.SetWords(t2), qt);
|
|
|
+ 2789 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2790 ELSIF SymTab.StrCompat(t, t2) THEN
|
|
|
+ 2791 QbeGen.StrEq(op, q, q2, qt);
|
|
|
+ 2792 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2793 ELSIF SymTab.IsLongFamily(t)
|
|
|
+ 2794 OR SymTab.IsLongFamily(t2) THEN
|
|
|
+ 2795 IF SymTab.IsIntFamily(t) THEN
|
|
|
+ 2796 QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
|
|
|
+ 2797 END;
|
|
|
+ 2798 IF SymTab.IsIntFamily(t2) THEN
|
|
|
+ 2799 QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
|
|
|
+ 2800 END;
|
|
|
+ 2801 QbeGen.CmpLong(op, q, q2, qt);
|
|
|
+ 2802 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
|
|
|
+ 2803 ELSE
|
|
|
+ 2804 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 2805 t := SymTab.BoolType();
|
|
|
+ 2806 QbeGen.Cmp(op, q, q2, qt, isR);
|
|
|
+ 2807 QbeGen.CopyOp(qt, q)
|
|
|
+ 2808 END
|
|
|
+ 2809 ELSE SemError(213); t := SymTab.InvalidType;
|
|
|
+ 2810 QbeGen.CopyOp("0", q)
|
|
|
+ 2811 END;
|
|
|
+ 2812 astCur := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB); .) ]
|
|
|
+ 2813 (. IF NOT astMade THEN astCur := astA END; .) .
|
|
|
+ 2814 Rel<VAR op: INTEGER>
|
|
|
+ 2815 = "=" (. op := SymTab.OpEq; .)
|
|
|
+ 2816 | "#" (. op := SymTab.OpNeq1; .)
|
|
|
+ 2817 | "<" (. op := SymTab.OpLt; .)
|
|
|
+ 2818 | "<=" (. op := SymTab.OpLe; .)
|
|
|
+ 2819 | ">" (. op := SymTab.OpGt; .)
|
|
|
+ 2820 | ">=" (. op := SymTab.OpGe; .)
|
|
|
+ 2821 | "IN" (. op := SymTab.OpIn; .) .
|
|
|
+ 2822 SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 2823 (. VAR t2, res2, lt, rt:
|
|
|
+ 2824 SymTab.TypeIndex;
|
|
|
+ 2825 op: INTEGER;
|
|
|
+ 2826 q2, qt, wq, qf, q2a, q2b:
|
|
|
+ 2827 QbeGen.QVal;
|
|
|
+ 2828 neg, isR, isL, folded:
|
|
|
+ 2829 BOOLEAN;
|
|
|
+ 2830 fok: BOOLEAN;
|
|
|
+ 2831 lw, rw, mw: CARDINAL;
|
|
|
+ 2832 lTrue, lNext, lDone, qr, qs: QbeGen.QVal;
|
|
|
+ 2833 astA, astB: AST.Node;
|
|
|
+ 2834 astSign, astOp: INTEGER; .)
|
|
|
+ 2835 = (. neg := FALSE; astSign := 0; .)
|
|
|
+ 2836 [ "+" (. neg := TRUE; astSign := 1; .)
|
|
|
+ 2837 | "-" (. neg := TRUE; astSign := -1; .) ]
|
|
|
+ 2838 Term<t, q> (. astA := astCur; IF neg THEN
|
|
|
+ 2839 IF QbeGen.IsImm(q) THEN
|
|
|
+ 2840 QbeGen.NegFold(q, q)
|
|
|
+ 2841 ELSE QbeGen.NewTemp(qt);
|
|
|
+ 2842 QbeGen.NegQ(q, qt,
|
|
|
+ 2843 SymTab.ClassOf(t)
|
|
|
+ 2844 = SymTab.ClReal);
|
|
|
+ 2845 QbeGen.CopyOp(qt, q)
|
|
|
+ 2846 END
|
|
|
+ 2847 END;
|
|
|
+ 2848 IF astSign < 0 THEN
|
|
|
+ 2849 astCur := AST.MakeUn(
|
|
|
+ 2850 AST.NkUnary, AST.OpSub, astA);
|
|
|
+ 2851 astA := astCur
|
|
|
+ 2852 END; .)
|
|
|
+ 2853 { AddOp<op> (. IF op = SymTab.OpOr THEN
|
|
|
+ 2854 QbeGen.DelayBegin END; .)
|
|
|
+ 2855 Term<t2, q2> (. astB := astCur; IF op = SymTab.OpOr THEN
|
|
|
+ 2856 QbeGen.DelayEnd END; .)
|
|
|
+ 2857 (. astOp := AST.OpAdd;
|
|
|
+ 2858 IF op = SymTab.OpSub THEN astOp := AST.OpSub
|
|
|
+ 2859 ELSIF op = SymTab.OpOr THEN astOp := AST.OpOr END;
|
|
|
+ 2860 astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
|
|
|
+ 2861 astCur := astA;
|
|
|
+ 2862 IF op = SymTab.OpOr THEN
|
|
|
+ 2863 (* short-circuit: if q is true the RHS is skipped *)
|
|
|
+ 2864 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
+ 2865 t := SymTab.BoolType()
|
|
|
+ 2866 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 2867 IF t # SymTab.InvalidType THEN
|
|
|
+ 2868 QbeGen.Slot4(qs);
|
|
|
+ 2869 QbeGen.NewLabel(lTrue);
|
|
|
+ 2870 QbeGen.NewLabel(lNext);
|
|
|
+ 2871 QbeGen.NewLabel(lDone);
|
|
|
+ 2872 QbeGen.Jnz(q, lTrue, lNext);
|
|
|
+ 2873 QbeGen.EmitLabel(lTrue);
|
|
|
+ 2874 QbeGen.StoreW(qs, "1");
|
|
|
+ 2875 QbeGen.Jmp(lDone);
|
|
|
+ 2876 QbeGen.EmitLabel(lNext);
|
|
|
+ 2877 QbeGen.DelayFlush;
|
|
|
+ 2878 QbeGen.StoreW(qs, q2);
|
|
|
+ 2879 QbeGen.Jmp(lDone);
|
|
|
+ 2880 QbeGen.EmitLabel(lDone);
|
|
|
+ 2881 QbeGen.LoadW(qs, qr);
|
|
|
+ 2882 QbeGen.CopyOp(qr, q)
|
|
|
+ 2883 ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
|
|
|
+ 2884 END
|
|
|
+ 2885 ELSIF (op = SymTab.OpAdd)
|
|
|
+ 2886 AND (SymTab.UStrCompat(t, t2)
|
|
|
+ 2887 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
|
|
|
+ 2888 AND (SymTab.ClassOf(t2) = SymTab.ClUStr))
|
|
|
+ 2889 OR ((SymTab.ClassOf(t) = SymTab.ClUStr)
|
|
|
+ 2890 AND (SymTab.ClassOf(t2) = SymTab.ClUChar))
|
|
|
+ 2891 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
|
|
|
+ 2892 AND (SymTab.ClassOf(t2) = SymTab.ClUChar))) THEN
|
|
|
+ 2893 (* UString concatenation: a UCHAR operand becomes a
|
|
|
+ 2894 1-codepoint UString; the result is a descriptor in the
|
|
|
+ 2895 shim's concat buffer. Work on copies so neither
|
|
|
+ 2896 operand is clobbered. *)
|
|
|
+ 2897 IF SymTab.ClassOf(t) = SymTab.ClUStr THEN
|
|
|
+ 2898 QbeGen.CopyOp(q, q2a)
|
|
|
+ 2899 ELSE
|
|
|
+ 2900 QbeGen.UStrFrom(q, q2a)
|
|
|
+ 2901 END;
|
|
|
+ 2902 IF SymTab.ClassOf(t2) = SymTab.ClUStr THEN
|
|
|
+ 2903 QbeGen.UStrCat(q2a, q2, qt)
|
|
|
+ 2904 ELSE
|
|
|
+ 2905 QbeGen.UStrFrom(q2, q2b);
|
|
|
+ 2906 QbeGen.UStrCat(q2a, q2b, qt)
|
|
|
+ 2907 END;
|
|
|
+ 2908 t := SymTab.NewUStr();
|
|
|
+ 2909 QbeGen.CopyOp(qt, q)
|
|
|
+ 2910 ELSIF (op = SymTab.OpAdd)
|
|
|
+ 2911 AND (SymTab.StrCompat(t, t2)
|
|
|
+ 2912 OR (SymTab.IsStrType(t)
|
|
|
+ 2913 AND (SymTab.ClassOf(t2) = SymTab.ClChar))
|
|
|
+ 2914 OR ((SymTab.ClassOf(t) = SymTab.ClChar)
|
|
|
+ 2915 AND SymTab.IsStrType(t2))) THEN
|
|
|
+ 2916 (* string concatenation; a CHAR operand becomes a
|
|
|
+ 2917 1-character string literal. When both operands are
|
|
|
+ 2918 constants, fold to a single string literal so a
|
|
|
+ 2919 constructor element stays compile-time. *)
|
|
|
+ 2920 QbeGen.StrFold(q, q2, SymTab.ClassOf(t), SymTab.ClassOf(t2),
|
|
|
+ 2921 qt, fok);
|
|
|
+ 2922 IF NOT fok THEN
|
|
|
+ 2923 IF SymTab.StrCompat(t, t2) THEN
|
|
|
+ 2924 QbeGen.StrCat(q, q2, qt)
|
|
|
+ 2925 ELSIF SymTab.IsStrType(t) THEN
|
|
|
+ 2926 QbeGen.DeclCharStr(q2, qs);
|
|
|
+ 2927 QbeGen.StrCat(q, qs, qt)
|
|
|
+ 2928 ELSE
|
|
|
+ 2929 QbeGen.DeclCharStr(q, qs);
|
|
|
+ 2930 QbeGen.StrCat(qs, q2, qt)
|
|
|
+ 2931 END
|
|
|
+ 2932 END;
|
|
|
+ 2933 t := SymTab.NewStr();
|
|
|
+ 2934 QbeGen.CopyOp(qt, q)
|
|
|
+ 2935 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
+ 2936 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 2937 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 2938 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
+ 2939 mw := lw;
|
|
|
+ 2940 IF rw > mw THEN mw := rw END;
|
|
|
+ 2941 IF op = SymTab.OpAdd THEN
|
|
|
+ 2942 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
|
|
|
+ 2943 ELSE
|
|
|
+ 2944 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
|
|
|
+ 2945 END;
|
|
|
+ 2946 t := SymTab.NewSet(
|
|
|
+ 2947 SymTab.NewSubR(0,
|
|
|
+ 2948 VAL(INTEGER, mw) * 32 - 1));
|
|
|
+ 2949 QbeGen.CopyOp(qt, q)
|
|
|
+ 2950 ELSE
|
|
|
+ 2951 IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
|
|
|
+ 2952 lt := t; rt := t2; t := res2
|
|
|
+ 2953 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 2954 IF t # SymTab.InvalidType THEN
|
|
|
+ 2955 isL := SymTab.IsLongFamily(t);
|
|
|
+ 2956 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 2957 folded := FALSE;
|
|
|
+ 2958 IF (NOT isL) AND (NOT isR)
|
|
|
+ 2959 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
+ 2960 IF op = SymTab.OpAdd THEN
|
|
|
+ 2961 folded := QbeGen.Fold2(0, q, q2, qf)
|
|
|
+ 2962 ELSE
|
|
|
+ 2963 folded := QbeGen.Fold2(1, q, q2, qf)
|
|
|
+ 2964 END
|
|
|
+ 2965 END;
|
|
|
+ 2966 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
+ 2967 ELSE
|
|
|
+ 2968 IF isL THEN
|
|
|
+ 2969 IF SymTab.IsIntFamily(lt) THEN
|
|
|
+ 2970 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
+ 2971 END;
|
|
|
+ 2972 IF SymTab.IsIntFamily(rt) THEN
|
|
|
+ 2973 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
+ 2974 END;
|
|
|
+ 2975 QbeGen.NewTemp(qt);
|
|
|
+ 2976 IF op = SymTab.OpAdd THEN
|
|
|
+ 2977 QbeGen.Op3L("add", qt, q, q2)
|
|
|
+ 2978 ELSE
|
|
|
+ 2979 QbeGen.Op3L("sub", qt, q, q2)
|
|
|
+ 2980 END
|
|
|
+ 2981 ELSE
|
|
|
+ 2982 QbeGen.NewTemp(qt);
|
|
|
+ 2983 IF op = SymTab.OpAdd THEN
|
|
|
+ 2984 QbeGen.Op3("add", qt, q, q2, isR)
|
|
|
+ 2985 ELSE
|
|
|
+ 2986 QbeGen.Op3("sub", qt, q, q2, isR)
|
|
|
+ 2987 END
|
|
|
+ 2988 END;
|
|
|
+ 2989 QbeGen.CopyOp(qt, q)
|
|
|
+ 2990 END
|
|
|
+ 2991 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 2992 END
|
|
|
+ 2993 END; .) } .
|
|
|
+ 2994 AddOp<VAR op: INTEGER>
|
|
|
+ 2995 = "+" (. op := SymTab.OpAdd; .)
|
|
|
+ 2996 | "-" (. op := SymTab.OpSub; .)
|
|
|
+ 2997 | "OR" (. op := SymTab.OpOr; .) .
|
|
|
+ 2998 Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 2999 (. VAR t2, res2, lt, rt:
|
|
|
+ 3000 SymTab.TypeIndex;
|
|
|
+ 3001 op: INTEGER;
|
|
|
+ 3002 q2, qt, wq, qf:
|
|
|
+ 3003 QbeGen.QVal;
|
|
|
+ 3004 isR, isL, folded: BOOLEAN;
|
|
|
+ 3005 lw, rw, mw: CARDINAL;
|
|
|
+ 3006 lNext, lFalse, lDone, qr, qs: QbeGen.QVal;
|
|
|
+ 3007 astA, astB: AST.Node;
|
|
|
+ 3008 astOp: INTEGER; .)
|
|
|
+ 3009 = Fact<t, q> (. astA := astCur; .) { MulOp<op> (. IF op = SymTab.OpAnd THEN
|
|
|
+ 3010 QbeGen.DelayBegin END; .)
|
|
|
+ 3011 Fact<t2, q2> (. astB := astCur; IF op = SymTab.OpAnd THEN
|
|
|
+ 3012 QbeGen.DelayEnd END; .)
|
|
|
+ 3013 (. astOp := AST.OpMul;
|
|
|
+ 3014 IF op = SymTab.OpSlash THEN astOp := AST.OpDiv
|
|
|
+ 3015 ELSIF op = SymTab.OpDiv THEN astOp := AST.OpDiv
|
|
|
+ 3016 ELSIF op = SymTab.OpMod THEN astOp := AST.OpMod
|
|
|
+ 3017 ELSIF op = SymTab.OpAnd THEN astOp := AST.OpAnd END;
|
|
|
+ 3018 astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
|
|
|
+ 3019 astCur := astA;
|
|
|
+ 3020 IF op = SymTab.OpAnd THEN
|
|
|
+ 3021 (* short-circuit: if q is false the RHS is skipped *)
|
|
|
+ 3022 IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
|
|
|
+ 3023 t := SymTab.BoolType()
|
|
|
+ 3024 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 3025 IF t # SymTab.InvalidType THEN
|
|
|
+ 3026 QbeGen.Slot4(qs);
|
|
|
+ 3027 QbeGen.NewLabel(lNext);
|
|
|
+ 3028 QbeGen.NewLabel(lFalse);
|
|
|
+ 3029 QbeGen.NewLabel(lDone);
|
|
|
+ 3030 QbeGen.Jnz(q, lNext, lFalse);
|
|
|
+ 3031 QbeGen.EmitLabel(lNext);
|
|
|
+ 3032 QbeGen.DelayFlush;
|
|
|
+ 3033 QbeGen.StoreW(qs, q2);
|
|
|
+ 3034 QbeGen.Jmp(lDone);
|
|
|
+ 3035 QbeGen.EmitLabel(lFalse);
|
|
|
+ 3036 QbeGen.StoreW(qs, "0");
|
|
|
+ 3037 QbeGen.Jmp(lDone);
|
|
|
+ 3038 QbeGen.EmitLabel(lDone);
|
|
|
+ 3039 QbeGen.LoadW(qs, qr);
|
|
|
+ 3040 QbeGen.CopyOp(qr, q)
|
|
|
+ 3041 ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
|
|
|
+ 3042 END
|
|
|
+ 3043 ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
|
|
|
+ 3044 AND (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 3045 AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 3046 lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
|
|
|
+ 3047 mw := lw;
|
|
|
+ 3048 IF rw > mw THEN mw := rw END;
|
|
|
+ 3049 IF op = SymTab.OpTimes THEN
|
|
|
+ 3050 QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
|
|
|
+ 3051 ELSE
|
|
|
+ 3052 QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
|
|
|
+ 3053 END;
|
|
|
+ 3054 t := SymTab.NewSet(
|
|
|
+ 3055 SymTab.NewSubR(0,
|
|
|
+ 3056 VAL(INTEGER, mw) * 32 - 1));
|
|
|
+ 3057 QbeGen.CopyOp(qt, q)
|
|
|
+ 3058 ELSE
|
|
|
+ 3059 IF SymTab.ArithCheck(t, t2,
|
|
|
+ 3060 (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
|
|
|
+ 3061 res2) THEN
|
|
|
+ 3062 lt := t; rt := t2; t := res2
|
|
|
+ 3063 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 3064 IF t # SymTab.InvalidType THEN
|
|
|
+ 3065 isL := SymTab.IsLongFamily(t);
|
|
|
+ 3066 isR := SymTab.ClassOf(t) = SymTab.ClReal;
|
|
|
+ 3067 folded := FALSE;
|
|
|
+ 3068 IF (NOT isL) AND (NOT isR)
|
|
|
+ 3069 AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
|
|
|
+ 3070 IF op = SymTab.OpTimes THEN
|
|
|
+ 3071 folded := QbeGen.Fold2(2, q, q2, qf)
|
|
|
+ 3072 ELSIF op = SymTab.OpDiv THEN
|
|
|
+ 3073 folded := QbeGen.Fold2(3, q, q2, qf)
|
|
|
+ 3074 ELSIF op = SymTab.OpMod THEN
|
|
|
+ 3075 folded := QbeGen.Fold2(4, q, q2, qf)
|
|
|
+ 3076 END
|
|
|
+ 3077 END;
|
|
|
+ 3078 IF folded THEN QbeGen.CopyOp(qf, q)
|
|
|
+ 3079 ELSE
|
|
|
+ 3080 IF isL THEN
|
|
|
+ 3081 IF SymTab.IsIntFamily(lt) THEN
|
|
|
+ 3082 QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
|
|
|
+ 3083 END;
|
|
|
+ 3084 IF SymTab.IsIntFamily(rt) THEN
|
|
|
+ 3085 QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
|
|
|
+ 3086 END;
|
|
|
+ 3087 QbeGen.NewTemp(qt);
|
|
|
+ 3088 IF op = SymTab.OpTimes THEN
|
|
|
+ 3089 QbeGen.Op3L("mul", qt, q, q2)
|
|
|
+ 3090 ELSIF (op = SymTab.OpDiv)
|
|
|
+ 3091 OR (op = SymTab.OpSlash) THEN
|
|
|
+ 3092 QbeGen.Op3L("div", qt, q, q2)
|
|
|
+ 3093 ELSE
|
|
|
+ 3094 QbeGen.Op3L("rem", qt, q, q2)
|
|
|
+ 3095 END
|
|
|
+ 3096 ELSE
|
|
|
+ 3097 QbeGen.NewTemp(qt);
|
|
|
+ 3098 IF op = SymTab.OpTimes THEN
|
|
|
+ 3099 QbeGen.Op3("mul", qt, q, q2, isR)
|
|
|
+ 3100 ELSIF (op = SymTab.OpDiv)
|
|
|
+ 3101 OR (op = SymTab.OpSlash) THEN
|
|
|
+ 3102 QbeGen.Op3("div", qt, q, q2, isR)
|
|
|
+ 3103 ELSE
|
|
|
+ 3104 QbeGen.Op3("rem", qt, q, q2, isR)
|
|
|
+ 3105 END
|
|
|
+ 3106 END;
|
|
|
+ 3107 QbeGen.CopyOp(qt, q)
|
|
|
+ 3108 END
|
|
|
+ 3109 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 3110 END
|
|
|
+ 3111 END; .) } .
|
|
|
+ 3112 MulOp<VAR op: INTEGER>
|
|
|
+ 3113 = "*" (. op := SymTab.OpTimes; .)
|
|
|
+ 3114 | "/" (. op := SymTab.OpSlash; .)
|
|
|
+ 3115 | "DIV" (. op := SymTab.OpDiv; .)
|
|
|
+ 3116 | "MOD" (. op := SymTab.OpMod; .)
|
|
|
+ 3117 | ( "AND" | "&" ) (. op := SymTab.OpAnd; .) .
|
|
|
+ 3118 Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 3119 (. VAR s: ARRAY [0 .. 255] OF CHAR;
|
|
|
+ 3120 et, dt, t2, st, ct2, et2:
|
|
|
+ 3121 SymTab.TypeIndex;
|
|
|
+ 3122 dk: INTEGER;
|
|
|
+ 3123 qd, q2, sq, qa, qm0, qr, qt:
|
|
|
+ 3124 QbeGen.QVal;
|
|
|
+ 3125 qn, vn: SymTab.Name;
|
|
|
+ 3126 vt: SymTab.TypeIndex;
|
|
|
+ 3127 c1, c2: INTEGER;
|
|
|
+ 3128 lo, hi: INTEGER;
|
|
|
+ 3129 isMax: BOOLEAN;
|
|
|
+ 3130 called, isHigh, sfx, isCh,
|
|
|
+ 3131 isU, uok, isStr: BOOLEAN;
|
|
|
+ 3132 ucp: INTEGER; astIsLit: BOOLEAN;
|
|
|
+ 3133 astD: AST.Node;
|
|
|
+ 3134 astCall: BOOLEAN;
|
|
|
+ 3135 astNode, astNot: AST.Node;
|
|
|
+ 3136 j: CARDINAL;
|
|
|
+ 3137 astArg2: AST.Node;
|
|
|
+ 3138 astBrace: AST.Node;
|
|
|
+ 3139 astRes: AST.Node; .)
|
|
|
+ 3140 = (. astIsLit := FALSE; .)
|
|
|
+ 3141 ( integer (. LexString(s);
|
|
|
+ 3142 QbeGen.NormInt(s, q); IF twoPhase THEN astIsLit := TRUE; astCur := AST.MakeLeaf(AST.NkIntLit, s) END;
|
|
|
+ 3143 t := SymTab.IntType(); .)
|
|
|
+ 3144 | charConst (. LexString(s);
|
|
|
+ 3145 QbeGen.NormLit(s, q, isCh);
|
|
|
+ 3146 IF twoPhase THEN
|
|
|
+ 3147 astIsLit := TRUE;
|
|
|
+ 3148 astCur := AST.MakeLeaf(
|
|
|
+ 3149 AST.NkCharLit, s)
|
|
|
+ 3150 END;
|
|
|
+ 3151 t := SymTab.CharType(); .)
|
|
|
+ 3152 | real (. LexString(s);
|
|
|
+ 3153 QbeGen.NormReal(s, q);
|
|
|
+ 3154 IF twoPhase THEN
|
|
|
+ 3155 astIsLit := TRUE;
|
|
|
+ 3156 astCur := AST.MakeLeaf(
|
|
|
+ 3157 AST.NkRealLit, s)
|
|
|
+ 3158 END;
|
|
|
+ 3159 t := SymTab.RealType(); .)
|
|
|
+ 3160 | string (. LexString(s);
|
|
|
+ 3161 IF twoPhase THEN
|
|
|
+ 3162 astIsLit := TRUE;
|
|
|
+ 3163 astCur := AST.MakeLeaf(
|
|
|
+ 3164 AST.NkStrLit, s)
|
|
|
+ 3165 END;
|
|
|
+ 3166 IF SymTab.StrLen(s) = 3 THEN
|
|
|
+ 3167 t := SymTab.CharType();
|
|
|
+ 3168 QbeGen.IntStr(
|
|
|
+ 3169 QbeGen.CharVal(s), q)
|
|
|
+ 3170 ELSE t := SymTab.NewStr();
|
|
|
+ 3171 QbeGen.DeclStr(s, q);
|
|
|
+ 3172 (* a literal's value IS its
|
|
|
+ 3173 static descriptor address *)
|
|
|
+ 3174 QbeGen.NoteAddr(q, q)
|
|
|
+ 3175 END; .)
|
|
|
+ 3176 | ustring (. LexString(s);
|
|
|
+ 3177 IF twoPhase THEN
|
|
|
+ 3178 astIsLit := TRUE;
|
|
|
+ 3179 astCur := AST.MakeLeaf(
|
|
|
+ 3180 AST.NkStrLit, s)
|
|
|
+ 3181 END;
|
|
|
+ 3182 QbeGen.DeclUStr(s, q, isU, ucp,
|
|
|
+ 3183 uok);
|
|
|
+ 3184 IF NOT uok THEN
|
|
|
+ 3185 SemError(234);
|
|
|
+ 3186 t := SymTab.InvalidType
|
|
|
+ 3187 ELSIF isU THEN
|
|
|
+ 3188 t := SymTab.UCharType();
|
|
|
+ 3189 QbeGen.IntStr(ucp, q)
|
|
|
+ 3190 ELSE
|
|
|
+ 3191 t := SymTab.NewUStr();
|
|
|
+ 3192 QbeGen.NoteAddr(q, q)
|
|
|
+ 3193 END; .)
|
|
|
+ 3194 | Design<dt, dk, qd, qn, sfx> (. astD := astCur; astCall := FALSE; astBrace := AST.NoNode;
|
|
|
+ 3195 astNArgs := 0; called := FALSE;
|
|
|
+ 3196 t := dt;
|
|
|
+ 3197 IF sfx THEN
|
|
|
+ 3198 IF dt =
|
|
|
+ 3199 SymTab.InvalidType THEN
|
|
|
+ 3200 QbeGen.CopyOp("0", q)
|
|
|
+ 3201 ELSIF (SymTab.ClassOf(dt) =
|
|
|
+ 3202 SymTab.ClRecord)
|
|
|
+ 3203 OR (SymTab.ClassOf(dt) =
|
|
|
+ 3204 SymTab.ClSet)
|
|
|
+ 3205 OR (SymTab.ClassOf(dt) =
|
|
|
+ 3206 SymTab.ClArray)
|
|
|
+ 3207 OR (SymTab.ClassOf(dt) =
|
|
|
+ 3208 SymTab.ClClass) THEN
|
|
|
+ 3209 QbeGen.CopyOp(qd, q)
|
|
|
+ 3210 ELSE QbeGen.ElemLoad(qd, dt,
|
|
|
+ 3211 q)
|
|
|
+ 3212 END
|
|
|
+ 3213 ELSE QbeGen.CopyOp(qd, q)
|
|
|
+ 3214 END;
|
|
|
+ 3215 IF (dk = SymTab.KindVar)
|
|
|
+ 3216 OR (dk = SymTab.KindParam)
|
|
|
+ 3217 OR (dk =
|
|
|
+ 3218 SymTab.KindField) THEN
|
|
|
+ 3219 IF sfx THEN
|
|
|
+ 3220 QbeGen.NoteAddr(q, qd)
|
|
|
+ 3221 ELSE
|
|
|
+ 3222 QbeGen.AddrOf(qn, qa);
|
|
|
+ 3223 QbeGen.NoteAddr(q, qa)
|
|
|
+ 3224 END
|
|
|
+ 3225 ELSIF sfx
|
|
|
+ 3226 AND (dt #
|
|
|
+ 3227 SymTab.InvalidType)
|
|
|
+ 3228 AND ((SymTab.ClassOf(dt) =
|
|
|
+ 3229 SymTab.ClArray)
|
|
|
+ 3230 OR (SymTab.ClassOf(dt) =
|
|
|
+ 3231 SymTab.ClSet)
|
|
|
+ 3232 OR (SymTab.ClassOf(dt) =
|
|
|
+ 3233 SymTab.ClRecord)) THEN
|
|
|
+ 3234 QbeGen.NoteAddr(qd, qd)
|
|
|
+ 3235 END; .)
|
|
|
+ 3236 [ TypedBraceLit<dt, q> (. t := dt; astCall := TRUE;
|
|
|
+ 3237 astBrace := astCur; .) ]
|
|
|
+ 3238 [ ArgList<qn, dt, qd, TRUE, FALSE, methCls, ct2, q2, called>
|
|
|
+ 3239 (. astCall := TRUE;
|
|
|
+ 3240 astNode := AstCallNode(astD);
|
|
|
+ 3241 astRes := astNode;
|
|
|
+ 3242 t := ct2;
|
|
|
+ 3243 QbeGen.CopyOp(q2, q);
|
|
|
+ 3244 sfx := FALSE; .)
|
|
|
+ 3245 { ResultComp<t, q, sfx, astRes> }
|
|
|
+ 3246 (. IF sfx THEN
|
|
|
+ 3247 IF t = SymTab.InvalidType THEN
|
|
|
+ 3248 QbeGen.CopyOp("0", q)
|
|
|
+ 3249 ELSIF (SymTab.ClassOf(t) #
|
|
|
+ 3250 SymTab.ClRecord)
|
|
|
+ 3251 AND (SymTab.ClassOf(t) # SymTab.ClSet)
|
|
|
+ 3252 AND (SymTab.ClassOf(t) # SymTab.ClArray)
|
|
|
+ 3253 AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
|
|
|
+ 3254 QbeGen.ElemLoad(q, t, q2);
|
|
|
+ 3255 QbeGen.CopyOp(q2, q)
|
|
|
+ 3256 END
|
|
|
+ 3257 END; .) ]
|
|
|
+ 3258 (. IF called THEN
|
|
|
+ 3259 astCur := astRes
|
|
|
+ 3260 ELSIF astCall THEN
|
|
|
+ 3261 astCur := astBrace
|
|
|
+ 3262 ELSE astCur := astD
|
|
|
+ 3263 END;
|
|
|
+ 3264 astIsLit := TRUE;
|
|
|
+ 3265 IF NOT called
|
|
|
+ 3266 AND (dk = SymTab.KindProc) THEN
|
|
|
+ 3267 (* bare zero-arg function
|
|
|
+ 3268 call (parentheses may be
|
|
|
+ 3269 omitted); a proper or
|
|
|
+ 3270 parameterised proc here
|
|
|
+ 3271 is 230 *)
|
|
|
+ 3272 IF (SymTab.ProcNPar(qn) = 0)
|
|
|
+ 3273 AND (SymTab.ProcRes(qn) #
|
|
|
+ 3274 SymTab.InvalidType) THEN
|
|
|
+ 3275 QbeGen.Mangled(qn,
|
|
|
+ 3276 SymTab.ProcUid(qn), qm0);
|
|
|
+ 3277 QbeGen.CallBegin(qm0,
|
|
|
+ 3278 SymTab.ProcRes(qn),
|
|
|
+ 3279 SymTab.ProcDepthOf(qn),
|
|
|
+ 3280 SymTab.IsExternal(qn));
|
|
|
+ 3281 QbeGen.CallEnd(TRUE, q);
|
|
|
+ 3282 t := SymTab.ProcRes(qn)
|
|
|
+ 3283 ELSE
|
|
|
+ 3284 (* procedure used as a
|
|
|
+ 3285 value (assign to a
|
|
|
+ 3286 procedure variable):
|
|
|
+ 3287 its code address *)
|
|
|
+ 3288 t := SymTab.ProcTypeOf(qn);
|
|
|
+ 3289 QbeGen.Mangled(qn,
|
|
|
+ 3290 SymTab.ProcUid(qn), qm0);
|
|
|
+ 3291 QbeGen.ProcAddr(qm0, q)
|
|
|
+ 3292 END
|
|
|
+ 3293 END; .)
|
|
|
+ 3294 | ( "HIGH" (. isHigh := TRUE; .)
|
|
|
+ 3295 | ( "LEN" | "LENGTH" ) (. isHigh := FALSE; .) )
|
|
|
+ 3296 "(" ( Design<dt, dk, qd, qn, sfx> (. isStr := FALSE;
|
|
|
+ 3297 isU := FALSE; .)
|
|
|
+ 3298 | string (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
|
|
|
+ 3299 isStr := TRUE;
|
|
|
+ 3300 isU := FALSE;
|
|
|
+ 3301 IF SymTab.StrLen(s) = 3 THEN
|
|
|
+ 3302 dt := SymTab.CharType();
|
|
|
+ 3303 QbeGen.IntStr(QbeGen.CharVal(s),
|
|
|
+ 3304 qd)
|
|
|
+ 3305 ELSE
|
|
|
+ 3306 dt := SymTab.NewStr();
|
|
|
+ 3307 QbeGen.DeclStr(s, qd);
|
|
|
+ 3308 QbeGen.NoteAddr(qd, qd)
|
|
|
+ 3309 END;
|
|
|
+ 3310 dk := -1;
|
|
|
+ 3311 qn[0] := CHR(0); .)
|
|
|
+ 3312 | ustring (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
|
|
|
+ 3313 QbeGen.DeclUStr(s, qd, isU, ucp,
|
|
|
+ 3314 uok);
|
|
|
+ 3315 isStr := FALSE;
|
|
|
+ 3316 IF NOT uok THEN
|
|
|
+ 3317 SemError(234);
|
|
|
+ 3318 dt := SymTab.InvalidType
|
|
|
+ 3319 ELSIF isU THEN
|
|
|
+ 3320 (* one codepoint: a UCHAR;
|
|
|
+ 3321 LEN is 1, HIGH is 0 *)
|
|
|
+ 3322 dt := SymTab.UCharType();
|
|
|
+ 3323 QbeGen.IntStr(ucp, qd)
|
|
|
+ 3324 ELSE
|
|
|
+ 3325 dt := SymTab.NewUStr();
|
|
|
+ 3326 QbeGen.NoteAddr(qd, qd)
|
|
|
+ 3327 END;
|
|
|
+ 3328 dk := -1;
|
|
|
+ 3329 qn[0] := CHR(0); .) )
|
|
|
+ 3330 ")"
|
|
|
+ 3331 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3332 IF isHigh THEN AST.SetChild(astNode, 0,
|
|
|
+ 3333 AST.MakeLeaf(AST.NkIdent, "HIGH"))
|
|
|
+ 3334 ELSE AST.SetChild(astNode, 0,
|
|
|
+ 3335 AST.MakeLeaf(AST.NkIdent, "LEN")) END;
|
|
|
+ 3336 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3337 astCur := astNode; astIsLit := TRUE;
|
|
|
+ 3338 IF (dt # SymTab.InvalidType)
|
|
|
+ 3339 AND (SymTab.ClassOf(dt) = SymTab.ClUStr) THEN
|
|
|
+ 3340 (* UString: the count is
|
|
|
+ 3341 the descriptor header *)
|
|
|
+ 3342 IF isHigh THEN
|
|
|
+ 3343 QbeGen.UStrLen(qd, qr);
|
|
|
+ 3344 QbeGen.DecQ(qr)
|
|
|
+ 3345 ELSE
|
|
|
+ 3346 QbeGen.UStrLen(qd, qr)
|
|
|
+ 3347 END;
|
|
|
+ 3348 t := SymTab.IntType();
|
|
|
+ 3349 QbeGen.CopyOp(qr, q)
|
|
|
+ 3350 ELSIF (dt # SymTab.InvalidType)
|
|
|
+ 3351 AND (SymTab.ClassOf(dt) = SymTab.ClUChar) THEN
|
|
|
+ 3352 (* single UCHAR codepoint *)
|
|
|
+ 3353 IF isHigh THEN
|
|
|
+ 3354 QbeGen.CopyOp("0", qr)
|
|
|
+ 3355 ELSE
|
|
|
+ 3356 QbeGen.CopyOp("1", qr)
|
|
|
+ 3357 END;
|
|
|
+ 3358 t := SymTab.IntType();
|
|
|
+ 3359 QbeGen.CopyOp(qr, q)
|
|
|
+ 3360 ELSIF isStr THEN
|
|
|
+ 3361 (* fold: content length at
|
|
|
+ 3362 compile time *)
|
|
|
+ 3363 IF SymTab.StrLen(s) = 3 THEN
|
|
|
+ 3364 c1 := 1
|
|
|
+ 3365 ELSE
|
|
|
+ 3366 c1 :=
|
|
|
+ 3367 SymTab.StrLen(s) - 2
|
|
|
+ 3368 END;
|
|
|
+ 3369 IF isHigh THEN
|
|
|
+ 3370 DEC(c1)
|
|
|
+ 3371 END;
|
|
|
+ 3372 QbeGen.IntStr(c1, qr);
|
|
|
+ 3373 t := SymTab.IntType();
|
|
|
+ 3374 QbeGen.CopyOp(qr, q)
|
|
|
+ 3375 ELSIF dt = SymTab.InvalidType THEN
|
|
|
+ 3376 t := SymTab.InvalidType;
|
|
|
+ 3377 QbeGen.CopyOp("0", q)
|
|
|
+ 3378 ELSIF SymTab.ClassOf(dt) #
|
|
|
+ 3379 SymTab.ClArray THEN
|
|
|
+ 3380 SemError(217);
|
|
|
+ 3381 t := SymTab.InvalidType;
|
|
|
+ 3382 QbeGen.CopyOp("0", q)
|
|
|
+ 3383 ELSE
|
|
|
+ 3384 IF isHigh THEN
|
|
|
+ 3385 IF SymTab.IsOpenArray(dt) THEN
|
|
|
+ 3386 QbeGen.OpenHi(qd, qr)
|
|
|
+ 3387 ELSE
|
|
|
+ 3388 QbeGen.IntStr(
|
|
|
+ 3389 SymTab.ArrayHi(dt), qr)
|
|
|
+ 3390 END
|
|
|
+ 3391 ELSE
|
|
|
+ 3392 IF SymTab.IsOpenArray(dt) THEN
|
|
|
+ 3393 QbeGen.LoadCount(qd, qr)
|
|
|
+ 3394 ELSE
|
|
|
+ 3395 QbeGen.IntStr(VAL(
|
|
|
+ 3396 INTEGER,
|
|
|
+ 3397 SymTab.ArrayLen(dt)),
|
|
|
+ 3398 qr)
|
|
|
+ 3399 END
|
|
|
+ 3400 END;
|
|
|
+ 3401 t := SymTab.IntType();
|
|
|
+ 3402 QbeGen.CopyOp(qr, q)
|
|
|
+ 3403 END; .)
|
|
|
+ 3404 | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 3405 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3406 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "SIZE"));
|
|
|
+ 3407 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3408 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3409 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 3410 t := SymTab.InvalidType;
|
|
|
+ 3411 QbeGen.CopyOp("0", q)
|
|
|
+ 3412 ELSE
|
|
|
+ 3413 QbeGen.IntStr(VAL(INTEGER,
|
|
|
+ 3414 SymTab.ObjectSize(dt)), q);
|
|
|
+ 3415 t := SymTab.IntType()
|
|
|
+ 3416 END; .)
|
|
|
+ 3417 | ( "SHIFT" (. isMax := FALSE; .)
|
|
|
+ 3418 | "ROTATE" (. isMax := TRUE; .) )
|
|
|
+ 3419 "(" Expr<et, q> (. astArg2 := astCur; .) "," Expr<et2, q2> ")"
|
|
|
+ 3420 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3421 IF isMax THEN AST.SetChild(astNode, 0,
|
|
|
+ 3422 AST.MakeLeaf(AST.NkIdent, "ROTATE"))
|
|
|
+ 3423 ELSE AST.SetChild(astNode, 0,
|
|
|
+ 3424 AST.MakeLeaf(AST.NkIdent, "SHIFT")) END;
|
|
|
+ 3425 IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
|
|
|
+ 3426 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
|
|
|
+ 3427 astCur := astNode; astIsLit := TRUE;
|
|
|
+ 3428 (* set shift/rotate: isMax
|
|
|
+ 3429 doubles as "rotate" *)
|
|
|
+ 3430 IF (et # SymTab.InvalidType)
|
|
|
+ 3431 AND (SymTab.ClassOf(et) =
|
|
|
+ 3432 SymTab.ClSet) THEN
|
|
|
+ 3433 QbeGen.SetShift(q, q2,
|
|
|
+ 3434 SymTab.SetWords(et),
|
|
|
+ 3435 SymTab.SetCount(et), isMax,
|
|
|
+ 3436 qt);
|
|
|
+ 3437 t := et;
|
|
|
+ 3438 QbeGen.CopyOp(qt, q)
|
|
|
+ 3439 ELSE SemError(230);
|
|
|
+ 3440 t := SymTab.InvalidType;
|
|
|
+ 3441 QbeGen.CopyOp("0", q)
|
|
|
+ 3442 END; .)
|
|
|
+ 3443 | ( "MIN" (. isMax := FALSE; .)
|
|
|
+ 3444 | "MAX" (. isMax := TRUE; .) )
|
|
|
+ 3445 "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 3446 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3447 IF isMax THEN AST.SetChild(astNode, 0,
|
|
|
+ 3448 AST.MakeLeaf(AST.NkIdent, "MAX"))
|
|
|
+ 3449 ELSE AST.SetChild(astNode, 0,
|
|
|
+ 3450 AST.MakeLeaf(AST.NkIdent, "MIN")) END;
|
|
|
+ 3451 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3452 astCur := astNode; astIsLit := TRUE;
|
|
|
+ 3453 IF (dt # SymTab.InvalidType)
|
|
|
+ 3454 AND (SymTab.ClassOf(dt) = SymTab.ClReal) THEN
|
|
|
+ 3455 (* REAL/LONGREAL: the
|
|
|
+ 3456 implementation bounds *)
|
|
|
+ 3457 IF isMax THEN
|
|
|
+ 3458 QbeGen.NormReal(
|
|
|
+ 3459 "3.402823e38", q)
|
|
|
+ 3460 ELSE QbeGen.NormReal(
|
|
|
+ 3461 "-3.402823e38", q)
|
|
|
+ 3462 END;
|
|
|
+ 3463 t := SymTab.RealType()
|
|
|
+ 3464 ELSIF (dt #
|
|
|
+ 3465 SymTab.InvalidType)
|
|
|
+ 3466 AND (SymTab.ClassOf(dt) =
|
|
|
+ 3467 SymTab.ClLong) THEN
|
|
|
+ 3468 IF isMax THEN
|
|
|
+ 3469 QbeGen.CopyOp(
|
|
|
+ 3470 "9223372036854775807", q)
|
|
|
+ 3471 ELSE QbeGen.CopyOp(
|
|
|
+ 3472 "-9223372036854775808", q)
|
|
|
+ 3473 END;
|
|
|
+ 3474 t := SymTab.LongType()
|
|
|
+ 3475 ELSIF SymTab.TypeBounds(dt, lo,
|
|
|
+ 3476 hi) THEN
|
|
|
+ 3477 IF isMax THEN
|
|
|
+ 3478 QbeGen.IntStr(hi, q)
|
|
|
+ 3479 ELSE QbeGen.IntStr(lo, q)
|
|
|
+ 3480 END;
|
|
|
+ 3481 t := SymTab.IntType()
|
|
|
+ 3482 ELSE SemError(230);
|
|
|
+ 3483 t := SymTab.InvalidType;
|
|
|
+ 3484 QbeGen.CopyOp("0", q)
|
|
|
+ 3485 END; .)
|
|
|
+ 3486 | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
|
|
|
+ 3487 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3488 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ADR"));
|
|
|
+ 3489 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3490 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3491 (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 3492 t := SymTab.InvalidType;
|
|
|
+ 3493 QbeGen.CopyOp("0", q)
|
|
|
+ 3494 ELSE
|
|
|
+ 3495 IF sfx THEN
|
|
|
+ 3496 QbeGen.CopyOp(qd, q)
|
|
|
+ 3497 ELSIF (dk = SymTab.KindVar)
|
|
|
+ 3498 OR (dk = SymTab.KindParam) THEN
|
|
|
+ 3499 QbeGen.AddrOf(qn, q)
|
|
|
+ 3500 ELSE SemError(230);
|
|
|
+ 3501 QbeGen.CopyOp("0", q)
|
|
|
+ 3502 END;
|
|
|
+ 3503 t := SymTab.AddrType()
|
|
|
+ 3504 END; .)
|
|
|
+ 3505 | "CHR" "(" Expr<et, q> ")"
|
|
|
+ 3506 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3507 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR"));
|
|
|
+ 3508 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3509 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3510 (. IF (et # SymTab.InvalidType)
|
|
|
+ 3511 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
+ 3512 SemError(211) END;
|
|
|
+ 3513 t := SymTab.CharType(); .)
|
|
|
+ 3514 | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
|
|
|
+ 3515 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3516 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ORD"));
|
|
|
+ 3517 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3518 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3519 (. IF et # SymTab.InvalidType THEN
|
|
|
+ 3520 IF (SymTab.ClassOf(et) #
|
|
|
+ 3521 SymTab.ClChar)
|
|
|
+ 3522 AND (SymTab.ClassOf(et) #
|
|
|
+ 3523 SymTab.ClBool)
|
|
|
+ 3524 AND (SymTab.ClassOf(et) #
|
|
|
+ 3525 SymTab.ClEnum)
|
|
|
+ 3526 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
+ 3527 SemError(211) END
|
|
|
+ 3528 END;
|
|
|
+ 3529 t := SymTab.IntType(); .)
|
|
|
+ 3530 | "CAP" "(" Expr<et, q> ")"
|
|
|
+ 3531 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3532 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CAP"));
|
|
|
+ 3533 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3534 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3535 (. QbeGen.CapQ(q, qa);
|
|
|
+ 3536 QbeGen.CopyOp(qa, q);
|
|
|
+ 3537 t := SymTab.CharType(); .)
|
|
|
+ 3538 | "UCHR" "(" Expr<et, q> ")"
|
|
|
+ 3539 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3540 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UCHR"));
|
|
|
+ 3541 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3542 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3543 (. (* UCHR: the UCHAR constructor.
|
|
|
+ 3544 CHAR -> UCHAR (identity);
|
|
|
+ 3545 INTEGER familly -> UCHAR
|
|
|
+ 3546 (codepoint value). *)
|
|
|
+ 3547 IF (et # SymTab.InvalidType)
|
|
|
+ 3548 AND (SymTab.ClassOf(et) # SymTab.ClChar)
|
|
|
+ 3549 AND NOT SymTab.IsIntFamily(et) THEN
|
|
|
+ 3550 SemError(211) END;
|
|
|
+ 3551 t := SymTab.UCharType(); .)
|
|
|
+ 3552 | "CHR8" "(" Expr<et, q> ")"
|
|
|
+ 3553 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3554 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR8"));
|
|
|
+ 3555 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3556 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3557 (. IF (et # SymTab.InvalidType)
|
|
|
+ 3558 AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
|
|
|
+ 3559 SemError(211) END;
|
|
|
+ 3560 QbeGen.WidenLong(q, qa);
|
|
|
+ 3561 QbeGen.CheckRange(qa, "0", "255");
|
|
|
+ 3562 t := SymTab.CharType(); .)
|
|
|
+ 3563 | "UORD" "(" Expr<et, q> ")"
|
|
|
+ 3564 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3565 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UORD"));
|
|
|
+ 3566 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3567 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3568 (. (* UORD(u): the codepoint as a
|
|
|
+ 3569 32-bit ordinal (INTEGER),
|
|
|
+ 3570 cf. ORD for CHAR. *)
|
|
|
+ 3571 IF (et # SymTab.InvalidType)
|
|
|
+ 3572 AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
|
|
|
+ 3573 SemError(211) END;
|
|
|
+ 3574 t := SymTab.IntType(); .)
|
|
|
+ 3575 | "ABS" "(" Expr<et, q> ")"
|
|
|
+ 3576 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3577 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ABS"));
|
|
|
+ 3578 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
|
|
|
+ 3579 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3580 (. IF (et # SymTab.InvalidType)
|
|
|
+ 3581 AND NOT SymTab.IsIntFamily(et)
|
|
|
+ 3582 AND (SymTab.ClassOf(et) #
|
|
|
+ 3583 SymTab.ClReal) THEN
|
|
|
+ 3584 SemError(211)
|
|
|
+ 3585 ELSE QbeGen.AbsQ(q, qa,
|
|
|
+ 3586 SymTab.ClassOf(et) =
|
|
|
+ 3587 SymTab.ClReal);
|
|
|
+ 3588 QbeGen.CopyOp(qa, q)
|
|
|
+ 3589 END;
|
|
|
+ 3590 t := et; .)
|
|
|
+ 3591 | "VAL" "(" GetIdent<vn> (. astArg2 := AST.MakeLeaf(AST.NkIdent, vn); .) "," Expr<et, q> ")"
|
|
|
+ 3592 (. astNode := AST.MakeNode(AST.NkCall);
|
|
|
+ 3593 AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "VAL"));
|
|
|
+ 3594 IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
|
|
|
+ 3595 IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
|
|
|
+ 3596 astCur := astNode; astIsLit := TRUE; .)
|
|
|
+ 3597 (. IF NOT SymTab.Lookup(vn) THEN
|
|
|
+ 3598 SemError(201);
|
|
|
+ 3599 t := SymTab.InvalidType
|
|
|
+ 3600 ELSE vt := SymTab.SymType(vn);
|
|
|
+ 3601 IF vt = SymTab.InvalidType THEN
|
|
|
+ 3602 t := SymTab.InvalidType
|
|
|
+ 3603 ELSIF et =
|
|
|
+ 3604 SymTab.InvalidType THEN
|
|
|
+ 3605 t := vt
|
|
|
+ 3606 ELSE
|
|
|
+ 3607 c1 := SymTab.ClassOf(et);
|
|
|
+ 3608 c2 := SymTab.ClassOf(vt);
|
|
|
+ 3609 IF (c1 = SymTab.ClInt)
|
|
|
+ 3610 AND (c2 = SymTab.ClLong) THEN
|
|
|
+ 3611 QbeGen.WidenLong(q, qa);
|
|
|
+ 3612 QbeGen.CopyOp(qa, q);
|
|
|
+ 3613 t := vt
|
|
|
+ 3614 ELSIF (c1 = SymTab.ClLong)
|
|
|
+ 3615 AND (c2 = SymTab.ClInt) THEN
|
|
|
+ 3616 QbeGen.NarrowLong(q, qa);
|
|
|
+ 3617 QbeGen.CopyOp(qa, q);
|
|
|
+ 3618 t := vt
|
|
|
+ 3619 ELSIF (c1 = SymTab.ClInt)
|
|
|
+ 3620 AND (c2 = SymTab.ClReal) THEN
|
|
|
+ 3621 QbeGen.ConvIR(q, qa);
|
|
|
+ 3622 QbeGen.CopyOp(qa, q);
|
|
|
+ 3623 t := vt
|
|
|
+ 3624 ELSIF (c1 = SymTab.ClLong)
|
|
|
+ 3625 AND (c2 = SymTab.ClReal) THEN
|
|
|
+ 3626 QbeGen.ConvLR(q, qa);
|
|
|
+ 3627 QbeGen.CopyOp(qa, q);
|
|
|
+ 3628 t := vt
|
|
|
+ 3629 ELSIF (c1 = SymTab.ClReal)
|
|
|
+ 3630 AND (c2 = SymTab.ClInt) THEN
|
|
|
+ 3631 QbeGen.ConvRI(q, qa);
|
|
|
+ 3632 QbeGen.CopyOp(qa, q);
|
|
|
+ 3633 t := vt
|
|
|
+ 3634 ELSIF (c1 = SymTab.ClReal)
|
|
|
+ 3635 AND (c2 = SymTab.ClLong) THEN
|
|
|
+ 3636 QbeGen.ConvRL(q, qa);
|
|
|
+ 3637 QbeGen.CopyOp(qa, q);
|
|
|
+ 3638 t := vt
|
|
|
+ 3639 ELSIF ((c1 = SymTab.ClInt)
|
|
|
+ 3640 OR (c1 =
|
|
|
+ 3641 SymTab.ClChar)
|
|
|
+ 3642 OR (c1 =
|
|
|
+ 3643 SymTab.ClBool)
|
|
|
+ 3644 OR (c1 =
|
|
|
+ 3645 SymTab.ClEnum))
|
|
|
+ 3646 AND ((c2 = SymTab.ClInt)
|
|
|
+ 3647 OR (c2 =
|
|
|
+ 3648 SymTab.ClChar)
|
|
|
+ 3649 OR (c2 =
|
|
|
+ 3650 SymTab.ClBool)
|
|
|
+ 3651 OR (c2 =
|
|
|
+ 3652 SymTab.ClEnum)) THEN
|
|
|
+ 3653 t := vt
|
|
|
+ 3654 ELSIF (c1 = SymTab.ClPtr)
|
|
|
+ 3655 AND (c2 = SymTab.ClPtr) THEN
|
|
|
+ 3656 t := vt
|
|
|
+ 3657 ELSIF (c1 = SymTab.ClReal)
|
|
|
+ 3658 AND (c2 = SymTab.ClReal) THEN
|
|
|
+ 3659 t := vt
|
|
|
+ 3660 ELSE SemError(230);
|
|
|
+ 3661 t := SymTab.InvalidType
|
|
|
+ 3662 END
|
|
|
+ 3663 END
|
|
|
+ 3664 END; .)
|
|
|
+ 3665 | "(" Expr<et, q> ")" (. t := et; astIsLit := TRUE; .)
|
|
|
+ 3666 | SetLit<st, sq> (. astIsLit := TRUE; t := st;
|
|
|
+ 3667 QbeGen.CopyOp(sq, q); .)
|
|
|
+ 3668 | ( "NOT" | "~" ) Fact<t2, q2> (. astNot := astCur;
|
|
|
+ 3669 IF SymTab.BoolCheck(t2) THEN
|
|
|
+ 3670 t := SymTab.BoolType()
|
|
|
+ 3671 ELSE SemError(212);
|
|
|
+ 3672 t := SymTab.InvalidType END;
|
|
|
+ 3673 IF t # SymTab.InvalidType THEN
|
|
|
+ 3674 QbeGen.NotQ(q2, q)
|
|
|
+ 3675 ELSE QbeGen.CopyOp("0", q)
|
|
|
+ 3676 END;
|
|
|
+ 3677 astIsLit := TRUE;
|
|
|
+ 3678 astCur := AST.MakeUn(
|
|
|
+ 3679 AST.NkUnary, AST.OpNot, astNot); .)
|
|
|
+ 3680 )
|
|
|
+ 3681 (. IF NOT astIsLit THEN astCur := AST.NoNode END; .) .
|
|
|
+ 3682 (* Set literals are SET OF [0..255] (8 words); elements validated
|
|
|
+ 3683 0..255 statically when foldable (222 otherwise), runtime trap
|
|
|
+ 3684 for computed elements. Ranges always lower via SetRange. *)
|
|
|
+ 3685 SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 3686 (. VAR astNode: AST.Node; .)
|
|
|
+ 3687 = "{" (. t := SymTab.NewSet(
|
|
|
+ 3688 SymTab.NewSubR(0, 255));
|
|
|
+ 3689 astNode := AST.MakeNode(AST.NkSetLit);
|
|
|
+ 3690 QbeGen.NewSetTemp(8, q);
|
|
|
+ 3691 QbeGen.SetZero(q, 8); .)
|
|
|
+ 3692 [ SetElem<t, q, astNode> { "," SetElem<t, q, astNode> } ]
|
|
|
+ 3693 "}" (. astCur := astNode; .) .
|
|
|
+ 3694 (* Typed brace constructor: TypeName{ elems } — BITSET{0} (a set)
|
|
|
+ 3695 or ArrayName{...} (an array constructor, GNU Modula-2). The
|
|
|
+ 3696 declared type sets the width (set) or element type (array). *)
|
|
|
+ 3697 TypedBraceLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
|
|
|
+ 3698 (. VAR nw: CARDINAL;
|
|
|
+ 3699 astNode, astTail: AST.Node;
|
|
|
+ 3700 savedCls: INTEGER; .)
|
|
|
+ 3701 = "{" (. savedCls := braceCls;
|
|
|
+ 3702 astNode := AST.MakeNode(AST.NkBraceLit);
|
|
|
+ 3703 AST.SetTy(astNode, vt);
|
|
|
+ 3704 astTail := astNode;
|
|
|
+ 3705 IF vt = SymTab.InvalidType THEN
|
|
|
+ 3706 braceCls := -1
|
|
|
+ 3707 ELSE braceCls :=
|
|
|
+ 3708 SymTab.ClassOf(vt)
|
|
|
+ 3709 END;
|
|
|
+ 3710 IF braceCls = SymTab.ClSet THEN
|
|
|
+ 3711 IF vt = SymTab.InvalidType THEN
|
|
|
+ 3712 nw := 8
|
|
|
+ 3713 ELSE nw := SymTab.SetWords(vt);
|
|
|
+ 3714 IF nw = 0 THEN nw := 8 END
|
|
|
+ 3715 END;
|
|
|
+ 3716 QbeGen.NewSetTemp(nw, q);
|
|
|
+ 3717 QbeGen.SetZero(q, nw)
|
|
|
+ 3718 ELSIF (braceCls =
|
|
|
+ 3719 SymTab.ClArray)
|
|
|
+ 3720 OR (braceCls =
|
|
|
+ 3721 SymTab.ClRecord)
|
|
|
+ 3722 OR (braceCls =
|
|
|
+ 3723 SymTab.ClClass) THEN
|
|
|
+ 3724 QbeGen.CtorBegin(vt)
|
|
|
+ 3725 ELSE
|
|
|
+ 3726 IF vt # SymTab.InvalidType THEN
|
|
|
+ 3727 SemError(230) END;
|
|
|
+ 3728 braceCls := -1
|
|
|
+ 3729 END; .)
|
|
|
+ 3730 [ BraceElem<vt, q, astNode, astTail>
|
|
|
+ 3731 { "," BraceElem<vt, q, astNode, astTail> } ]
|
|
|
+ 3732 "}" (. IF (braceCls = SymTab.ClArray)
|
|
|
+ 3733 OR (braceCls =
|
|
|
+ 3734 SymTab.ClRecord)
|
|
|
+ 3735 OR (braceCls =
|
|
|
+ 3736 SymTab.ClClass) THEN
|
|
|
+ 3737 QbeGen.CtorEnd(q)
|
|
|
+ 3738 ELSIF braceCls # SymTab.ClSet THEN
|
|
|
+ 3739 QbeGen.CopyOp("0", q)
|
|
|
+ 3740 END;
|
|
|
+ 3741 braceCls := savedCls; .)
|
|
|
+ 3742 (. astCur := astNode; .) .
|
|
|
+ 3743 BraceElem<vt: SymTab.TypeIndex; VAR sq: QbeGen.QVal;
|
|
|
+ 3744 VAR node, tail: AST.Node>
|
|
|
+ 3745 (. VAR et, et2: SymTab.TypeIndex;
|
|
|
+ 3746 qe, q2: QbeGen.QVal;
|
|
|
+ 3747 v, v2, reps, k: INTEGER;
|
|
|
+ 3748 elem: SymTab.TypeIndex;
|
|
|
+ 3749 lo: INTEGER;
|
|
|
+ 3750 span: CARDINAL;
|
|
|
+ 3751 cl, cl2: INTEGER;
|
|
|
+ 3752 hasR, hasB: BOOLEAN;
|
|
|
+ 3753 astEl: AST.Node; .)
|
|
|
+ 3754 = (. hasR := FALSE; hasB := FALSE;
|
|
|
+ 3755 reps := 1; .)
|
|
|
+ 3756 Expr<et, qe> (. astEl := astCur; .)
|
|
|
+ 3757 [ ".." Expr<et2, q2> (. astEl := AST.MakeBin(
|
|
|
+ 3758 AST.NkSubrange, 0, astEl, astCur);
|
|
|
+ 3759 hasR := TRUE; .) ]
|
|
|
+ 3760 [ "BY" Expr<et2, q2> (. hasB := TRUE; .) ]
|
|
|
+ 3761 (. IF braceCls = SymTab.ClSet THEN
|
|
|
+ 3762 IF hasB THEN SemError(230) END;
|
|
|
+ 3763 lo := SymTab.SetBaseLo(vt);
|
|
|
+ 3764 span := SymTab.SetCount(vt);
|
|
|
+ 3765 IF (et = SymTab.InvalidType)
|
|
|
+ 3766 OR (hasR AND (et2 =
|
|
|
+ 3767 SymTab.InvalidType)) THEN
|
|
|
+ 3768 ELSE cl :=
|
|
|
+ 3769 SymTab.ClassOf(et);
|
|
|
+ 3770 IF hasR THEN
|
|
|
+ 3771 cl2 :=
|
|
|
+ 3772 SymTab.ClassOf(et2)
|
|
|
+ 3773 ELSE cl2 := SymTab.ClInt
|
|
|
+ 3774 END;
|
|
|
+ 3775 IF NOT SymTab.SetElemClassOk(cl)
|
|
|
+ 3776 OR (hasR AND NOT
|
|
|
+ 3777 SymTab.SetElemClassOk(cl2))
|
|
|
+ 3778 THEN
|
|
|
+ 3779 SemError(222)
|
|
|
+ 3780 ELSIF hasR
|
|
|
+ 3781 AND SymTab.ConstInt(qe, v)
|
|
|
+ 3782 AND SymTab.ConstInt(q2,
|
|
|
+ 3783 v2)
|
|
|
+ 3784 AND ((v < lo)
|
|
|
+ 3785 OR (v2 < lo)
|
|
|
+ 3786 OR (v >= lo +
|
|
|
+ 3787 VAL(INTEGER, span))
|
|
|
+ 3788 OR (v2 >= lo +
|
|
|
+ 3789 VAL(INTEGER, span))
|
|
|
+ 3790 OR (v > v2)) THEN
|
|
|
+ 3791 SemError(222)
|
|
|
+ 3792 ELSIF hasR THEN
|
|
|
+ 3793 QbeGen.SetRange(sq, qe, q2,
|
|
|
+ 3794 lo, span)
|
|
|
+ 3795 ELSIF SymTab.ConstInt(qe,
|
|
|
+ 3796 v)
|
|
|
+ 3797 AND ((v < lo)
|
|
|
+ 3798 OR (v >= lo +
|
|
|
+ 3799 VAL(INTEGER,
|
|
|
+ 3800 span))) THEN
|
|
|
+ 3801 SemError(222)
|
|
|
+ 3802 ELSE QbeGen.SetBit(sq, qe,
|
|
|
+ 3803 lo, span)
|
|
|
+ 3804 END
|
|
|
+ 3805 END
|
|
|
+ 3806 ELSIF (braceCls = SymTab.ClArray)
|
|
|
+ 3807 OR (braceCls =
|
|
|
+ 3808 SymTab.ClRecord)
|
|
|
+ 3809 OR (braceCls =
|
|
|
+ 3810 SymTab.ClClass) THEN
|
|
|
+ 3811 IF hasR THEN SemError(230) END;
|
|
|
+ 3812 reps := 1;
|
|
|
+ 3813 IF hasB THEN
|
|
|
+ 3814 IF SymTab.ConstInt(q2, v2)
|
|
|
+ 3815 AND (v2 >= 1) THEN
|
|
|
+ 3816 reps := v2
|
|
|
+ 3817 ELSE SemError(230)
|
|
|
+ 3818 END
|
|
|
+ 3819 END;
|
|
|
+ 3820 k := 0;
|
|
|
+ 3821 WHILE k < reps DO
|
|
|
+ 3822 QbeGen.CtorElem(qe);
|
|
|
+ 3823 INC(k)
|
|
|
+ 3824 END
|
|
|
+ 3825 END; .)
|
|
|
+ 3826 (. (* the BY form repeats the
|
|
|
+ 3827 element; keep the AST in
|
|
|
+ 3828 step with CtorElem *)
|
|
|
+ 3829 k := 0;
|
|
|
+ 3830 WHILE k < reps DO
|
|
|
+ 3831 AstAppend(AST.NkBlock,
|
|
|
+ 3832 node, tail, astEl);
|
|
|
+ 3833 INC(k)
|
|
|
+ 3834 END; .) .
|
|
|
+ 3835 SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal; node: AST.Node> (. VAR et, et2: SymTab.TypeIndex;
|
|
|
+ 3836 qe, q2: QbeGen.QVal;
|
|
|
+ 3837 v, v2: INTEGER;
|
|
|
+ 3838 lo: INTEGER;
|
|
|
+ 3839 span: CARDINAL;
|
|
|
+ 3840 cl, cl2: INTEGER;
|
|
|
+ 3841 hasR: BOOLEAN;
|
|
|
+ 3842 astEl: AST.Node; .)
|
|
|
+ 3843 = (. hasR := FALSE; .)
|
|
|
+ 3844 Expr<et, qe> (. astEl := astCur; .)
|
|
|
+ 3845 [ ".." Expr<et2, q2> (. astEl := AST.MakeBin(
|
|
|
+ 3846 AST.NkSubrange, 0, astEl, astCur);
|
|
|
+ 3847 hasR := TRUE; .) ]
|
|
|
+ 3848 (. lo := SymTab.SetBaseLo(st);
|
|
|
+ 3849 span := SymTab.SetCount(st);
|
|
|
+ 3850 IF (et = SymTab.InvalidType)
|
|
|
+ 3851 OR (hasR AND (et2 =
|
|
|
+ 3852 SymTab.InvalidType)) THEN
|
|
|
+ 3853 ELSE cl :=
|
|
|
+ 3854 SymTab.ClassOf(et);
|
|
|
+ 3855 IF hasR THEN
|
|
|
+ 3856 cl2 :=
|
|
|
+ 3857 SymTab.ClassOf(et2)
|
|
|
+ 3858 ELSE cl2 := SymTab.ClInt
|
|
|
+ 3859 END;
|
|
|
+ 3860 IF NOT SymTab.SetElemClassOk(cl)
|
|
|
+ 3861 OR (hasR AND NOT
|
|
|
+ 3862 SymTab.SetElemClassOk(cl2))
|
|
|
+ 3863 THEN
|
|
|
+ 3864 SemError(222)
|
|
|
+ 3865 ELSIF hasR
|
|
|
+ 3866 AND SymTab.ConstInt(qe, v)
|
|
|
+ 3867 AND SymTab.ConstInt(q2,
|
|
|
+ 3868 v2)
|
|
|
+ 3869 AND ((v < lo)
|
|
|
+ 3870 OR (v2 < lo)
|
|
|
+ 3871 OR (v >= lo +
|
|
|
+ 3872 VAL(INTEGER, span))
|
|
|
+ 3873 OR (v2 >= lo +
|
|
|
+ 3874 VAL(INTEGER, span))
|
|
|
+ 3875 OR (v > v2)) THEN
|
|
|
+ 3876 SemError(222)
|
|
|
+ 3877 ELSIF hasR THEN
|
|
|
+ 3878 QbeGen.SetRange(sq, qe, q2,
|
|
|
+ 3879 lo, span)
|
|
|
+ 3880 ELSIF SymTab.ConstInt(qe,
|
|
|
+ 3881 v)
|
|
|
+ 3882 AND ((v < lo)
|
|
|
+ 3883 OR (v >= lo +
|
|
|
+ 3884 VAL(INTEGER,
|
|
|
+ 3885 span))) THEN
|
|
|
+ 3886 SemError(222)
|
|
|
+ 3887 ELSE QbeGen.SetBit(sq, qe,
|
|
|
+ 3888 lo, span)
|
|
|
+ 3889 END
|
|
|
+ 3890 END; .)
|
|
|
+ 3891 (. AST.SetChild(node,
|
|
|
+ 3892 AST.NChild(node), astEl); .) .
|
|
|
+ 3893 GetIdent<VAR n: SymTab.Name>
|
|
|
+ 3894 = ident (. LexName(n); .) .
|
|
|
+ 3895
|
|
|
+ 3896 END M2.
|
|
|
|
|
|
0 errors
|
|
|
|
