DIRECTORY Rope, IO, Basics, Atom, Convert, AlgebraClasses, MathConstructors, Bools; BoolsImpl: CEDAR PROGRAM IMPORTS IO, Convert, AlgebraClasses, MathConstructors EXPORTS Bools = BEGIN OPEN Bools, Convert, AC: AlgebraClasses; BoolsError: PUBLIC SIGNAL [reason: ATOM _ $Unspecified] = CODE; bitsPerWord: CARDINAL = Basics.bitsPerWord; CARD: TYPE = LONG CARDINAL; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; Object: TYPE = AC.Object; Method: TYPE = AC.Method; TypeError: PUBLIC ERROR [message: ATOM _ $Unspecified] = CODE; PrintName: AC.ToRopeOp = { RETURN["Bools"]; }; ShortPrintName: AC.ToRopeOp = { RETURN["B"]; }; LegalFirstChar: AC.LegalFirstCharOp = { SELECT char FROM 'T, 'F => RETURN[TRUE]; ENDCASE; RETURN[FALSE]; }; ToExpr: AC.ToExprOp = { data: BoolData _ NARROW[in.data]; RETURN[MathConstructors.MakeBool[Convert.RopeFromBool[data^] ] ]; }; Recast: AC.BinaryOp = { IF NOT AC.StructureEqual[firstArg.class, Bools] THEN RETURN[NIL] ELSE RETURN[firstArg]; }; CanRecast: AC.BinaryPredicate = { firstArgStructure: Object _ IF firstArg.flavor = StructureElement THEN firstArg.class ELSE IF firstArg.flavor = Structure THEN firstArg ELSE ERROR; SELECT TRUE FROM AC.StructureEqual[firstArgStructure, Bools] => RETURN[TRUE]; ENDCASE; RETURN[FALSE]; }; Read: PUBLIC AC.ReadOp ~ { RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ IO.GetBool[in] ] ] ] ]; }; FromRope: PUBLIC AC.FromRopeOp = { stream: IO.STREAM _ IO.RIS[in]; RETURN[ Read[stream, structure] ]; }; ToRope: PUBLIC AC.ToRopeOp = { data: BoolData _ NARROW[in.data]; RETURN[ Convert.RopeFromBool[data^] ]; }; Write: PUBLIC AC.WriteOp = { IO.PutRope[ stream, ToRope[in] ] }; FromBOOL: PUBLIC AC.FromBOOLOp = { RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ in] ] ] ]; }; ToBOOL: PUBLIC PROC [bool: Bool] RETURNS [BOOL] = { data: BoolData _ NARROW[bool.data]; RETURN[data^]; }; Equal: PUBLIC AC.BinaryPredicate ~ { firstData: BoolData _ NARROW[firstArg.data]; secondData: BoolData _ NARROW[secondArg.data]; RETURN[ firstData^ = secondData^ ] }; Disjunct: PUBLIC AC.BinaryOp ~ { firstData: BoolData _ NARROW[firstArg.data]; secondData: BoolData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ firstData^ OR secondData^ ] ] ] ]; }; Conjunct: PUBLIC AC.BinaryOp ~ { firstData: BoolData _ NARROW[firstArg.data]; secondData: BoolData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ firstData^ AND secondData^ ] ] ] ]; }; Negate: PUBLIC AC.UnaryOp ~ { data: BoolData _ NARROW[arg.data]; RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ NOT data^ ] ] ] ]; }; Paren: PUBLIC AC.UnaryOp ~ { RETURN[NEW[AC.ObjectRec _ [ flavor: StructureElement, class: Bools, data: arg.data ] ] ]; }; Difference: PUBLIC AC.BinaryOp ~ { firstData: BoolData _ NARROW[firstArg.data]; secondData: BoolData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ class: Bools, flavor: StructureElement, data: NEW[BOOL _ firstData^ AND NOT secondData^ ] ] ] ]; }; BoolClass: Object _ AC.MakeClass["BoolClass", NIL, NIL]; Bools: PUBLIC Object _ AC.MakeStructure["Bools", BoolClass, NIL]; True: PUBLIC Object _ FromBOOL[TRUE]; False: PUBLIC Object _ FromBOOL[FALSE]; categoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ lattice], NIL, "category"]; groundStructureMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "groundStructure"]; shortPrintNameMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ShortPrintName], NIL, "shortPrintName"]; recastMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Recast], NIL, "recast"]; canRecastMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ CanRecast], NIL, "canRecast"]; toExprMethod: Method _ AC.MakeMethod[ToExprOp, FALSE, NEW[AC.ToExprOp _ ToExpr], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "toExpr"]; legalFirstCharMethod: Method _ AC.MakeMethod[LegalFirstCharOp, FALSE, NEW[AC.LegalFirstCharOp _ LegalFirstChar], NIL, "legalFirstChar"]; readMethod: Method _ AC.MakeMethod[ReadOp, FALSE, NEW[AC.ReadOp _ Read], NIL, "read"]; fromRopeMethod: Method _ AC.MakeMethod[FromRopeOp, TRUE, NEW[AC.FromRopeOp _ FromRope], NIL, "fromRope"]; toRopeMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ToRope], NIL, "toRope"]; boolMethod: Method _ AC.MakeMethod[FromRopeOp, FALSE, NEW[AC.FromRopeOp _ FromRope], NIL, "bool"]; fromBOOLMethod: Method _ AC.MakeMethod[FromBOOLOp, FALSE, NEW[AC.FromBOOLOp _ FromBOOL], NIL, "fromBOOL"]; parenMethod: Method _ AC.MakeMethod[UnaryOp, FALSE, NEW[AC.UnaryOp _ Paren], NIL, "paren"]; orMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Disjunct], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "or"]; notMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Negate], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "not"]; differenceMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Difference], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "difference"]; andMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Conjunct], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "and"]; equalMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ Equal], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "equals"]; AC.AddMethodToClass[$category, categoryMethod, BoolClass]; AC.AddMethodToClass[$groundStructure, categoryMethod, BoolClass]; AC.AddMethodToClass[$recast, recastMethod, BoolClass]; AC.AddMethodToClass[$shortPrintName, shortPrintNameMethod, BoolClass]; AC.AddMethodToClass[$canRecast, canRecastMethod, BoolClass]; AC.AddMethodToClass[$toExpr, toExprMethod, BoolClass]; AC.AddMethodToClass[$legalFirstChar, legalFirstCharMethod, BoolClass]; AC.AddMethodToClass[$read, readMethod, BoolClass]; AC.AddMethodToClass[$fromRope, fromRopeMethod, BoolClass]; AC.AddMethodToClass[$toRope, toRopeMethod, BoolClass]; AC.AddMethodToClass[$bool, boolMethod, BoolClass]; AC.AddMethodToClass[$fromBOOL, fromBOOLMethod, BoolClass]; AC.AddMethodToClass[$paren, parenMethod, BoolClass]; AC.AddMethodToClass[$or, orMethod, BoolClass]; AC.AddMethodToClass[$not, notMethod, BoolClass]; AC.AddMethodToClass[$difference, differenceMethod, BoolClass]; AC.AddMethodToClass[$and, andMethod, BoolClass]; AC.AddMethodToClass[$eqFormula, equalMethod, BoolClass]; AC.InstallStructure[Bools]; END. èBoolsImpl.mesa Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT Types Variables I/O and Conversion Arithmetic Start Code BoolClass: AC.StructureClass _ NEW[AC.StructureClassRec _ [ category: lattice, printName: ClassPrintName, shortPrintName: ClassShortPrintName, structureEqual: AC.defaultStructureEqualityTest, isElementOf: AC.defaultElementOfProc, legalFirstChar: ClassLegalFirstChar, read: Read, fromRope: FromRope, toRope: ToRope, write: Write, toExpr: ClassToExpr, add: Disjunct, negate: Negate, -- hack, multiply: Conjunct, divide: Difference, booleanAlgebra: TRUE, complement: Negate, equal: ClassEqual, propList: NIL ] ]; Bools: PUBLIC AC.Structure _ NEW[AC.StructureRec _ [ class: BoolClass, instanceData: NIL ] ]; ‌ت 7کJڑœ™J™3J™ڑدk ک JڑœکIcodeڑ‌œکKکKکKکJکJکJڑœک—Jکhead2ڑدn œ‌œ‌کJڑ‌œ‌œ+ک5Jڑ‌œک Jک—Jڑœ‌œ‌œ‌œک0headڑ‍™Jڑ ‍ œ‌œ‌œ ‌œ‌œک?Kڑœ ‌œک+Kڑ‌œ‌œ‌œ‌œکKڑ‌œ‌œ‌œکKڑ‌œ‌œ‌œ‌œکKڑœ‌œ‌œکKڑœ‌œ‌œکKکJڑ ‍ œ‌œ‌œ‌œ‌œک>—ڑ‍ ™ ڑ‍ œ‌œ کJڑ‌œ کJک—ڑ‍œ‌œ کJڑ‌œکJک—ڑ‍œ‌œک'ڑ‌œ‌کKڑœ ‌œ‌œکKڑ‌œک—Kڑ‌œ‌œکJک—ڑ‍œ‌œ کJڑœ‌œ ک!Jڑ‌œ;کAJڑœک—ڑ‍œ‌œ کJڑ‌œ‌œ‌œ'‌œ‌œ‌œ‌œ‌œکWJڑœکJک—ڑ‍ œ‌œک!Jڑœ‌œ$‌œ‌œ‌œ‌œ ‌œ‌œک“ڑ‌œ‌œ‌کKڑ‌œ-‌œ‌œکJڑ‌œ.ک0Jڑ‌œ6ک8JکJڑ‌œ‍œکJکJک—Jڑ‌œکJک—…—¬&ث