DIRECTORY Rope, IO, Basics, Atom, Convert, AlgebraClasses, MathConstructors, Expressions; ExpressionsImpl: CEDAR PROGRAM IMPORTS IO, Convert, AlgebraClasses, MathConstructors EXPORTS Expressions = BEGIN OPEN Expressions, Convert, AC: AlgebraClasses; ExpressionsError: PUBLIC SIGNAL [reason: ATOM _ $Unspecified] = CODE; bitsPerWord: CARDINAL = Basics.bitsPerWord; CARD: TYPE = LONG CARDINAL; ROPE: TYPE = Rope.ROPE; STREAM: TYPE = IO.STREAM; ClassPrintName: AC.PrintNameProc = { RETURN["Expressions"]; }; ClassLegalFirstChar: AC.LegalFirstCharOp = { RETURN[TRUE]; }; ClassToExpr: AC.ToExprOp = { data: ExpressionData _ NARROW[in.data]; RETURN[data]; }; ClassZero: AC.NullaryOp = { RETURN[ MathConstructors.MakeInt["0"] ] }; ClassOne: AC.NullaryOp = { RETURN[ MathConstructors.MakeInt["1"] ] }; ExpressionClass: AC.StructureClass _ NEW[AC.StructureClassRec _ [ category: field, printName: ClassPrintName, structureEqual: AC.defaultStructureEqualityTest, characteristic: ClassCharacteristic, isElementOf: AC.defaultElementOfProc, legalFirstChar: ClassLegalFirstChar, read: Read, fromRope: FromRope, toRope: ToRope, write: Write, toExpr: ClassToExpr, add: Add, negate: Negate, subtract: Subtract, zero: ClassZero, multiply: Multiply, commutative: TRUE, invert: Invert, divide: Divide, one: ClassOne, equal: Equal, ordered: TRUE, sign: Sign, abs: Abs, compare: Compare, completeField: TRUE, realField: TRUE, realClosedField: TRUE, algebraicallyClosedField: FALSE, propList: NIL ] ]; Expressions: PUBLIC AC.Structure _ NEW[AC.StructureRec _ [ class: ExpressionClass, instanceData: NIL ] ]; ExpressionOne: Expression _ FromREAL[1.0]; -- do after Expressions set ExpressionZero: Expression _ FromREAL[0.0]; Read: PUBLIC AC.ReadOp ~ { RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ IO.GetExpression[in] ] ] ] ]; }; FromRope: PUBLIC AC.FromRopeOp = { stream: IO.STREAM _ IO.RIS[in]; RETURN[ Read[stream, structure] ]; }; ToRope: PUBLIC AC.ToRopeOp = { data: ExpressionData _ NARROW[in.data]; RETURN[ Convert.RopeFromExpression[data^] ]; }; Write: PUBLIC AC.WriteOp = { IO.PutRope[ stream, ToRope[in] ] }; FromREAL: PUBLIC PROC [real: REAL] RETURNS [Expression] = { RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ real] ] ] ]; }; ToREAL: PUBLIC PROC [real: Expression] RETURNS [REAL] = { data: ExpressionData _ NARROW[real.data]; RETURN[data^]; }; Add: PUBLIC AC.BinaryOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ firstData^ + secondData^ ] ] ] ]; }; Negate: PUBLIC AC.UnaryOp ~ { data: ExpressionData _ NARROW[arg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ - data^ ] ] ] ]; }; Subtract: PUBLIC AC.BinaryOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ firstData^ - secondData^ ] ] ] ]; }; Multiply: PUBLIC AC.BinaryOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ firstData^ * secondData^ ] ] ] ]; }; Invert: PUBLIC AC.UnaryOp ~ { data: ExpressionData _ NARROW[arg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ 1.0 / data^ ] ] ] ]; }; Divide: PUBLIC AC.BinaryOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ firstData^ / secondData^ ] ] ] ]; }; Sign: PUBLIC AC.CompareToZeroOp = { data: ExpressionData _ NARROW[arg.data]; SELECT data^ FROM < 0.0 => RETURN[less]; = 0.0 => RETURN[equal]; ENDCASE => RETURN[greater]; }; Abs: PUBLIC AC.UnaryOp ~ { data: ExpressionData _ NARROW[arg.data]; RETURN[NEW[AC.ObjectRec _ [ structure: Expressions, data: NEW[REAL _ ABS[data^] ] ] ] ]; }; Compare: PUBLIC AC.BinaryCompareOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; SELECT firstData^ FROM < secondData^ => RETURN[less]; = secondData^ => RETURN[equal]; ENDCASE => RETURN[greater]; }; Equal: PUBLIC AC.EqualityOp ~ { firstData: ExpressionData _ NARROW[firstArg.data]; secondData: ExpressionData _ NARROW[secondArg.data]; RETURN[ firstData^ = secondData^] }; END. ΘExpressionsImpl.mesa Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT Types Variables SELECT char FROM = '., IN ['0..'9] => RETURN[TRUE]; ENDCASE; I/O and Conversion Arithmetic Comparison Κ˜Jšœ™J™3J™šΟk ˜ Jšœ˜Icodešœ˜K˜K˜K˜J˜J˜Jšœ ˜ —J˜head2šœœ˜Jšœœ+˜5Jšœ ˜J˜—Jšœœœœ˜6headšΟn™Jš œœœ œœ˜EKšœ œ˜+Kšœœœœ˜Kšœœœ˜Kšœœœœ˜—šž ™ šžœœ˜$Jšœ˜J˜—šžœœ˜,šœ™Kšœ œœ™"Kšœ™—Kšœœ˜ J˜—šž œœ ˜Kšœœ ˜'Jšœ˜ Jšœ˜—šž œœ˜Jšœ!˜'Jšœ˜—šžœœ˜Jšœ!˜'Jšœ˜—šžœœœœ˜AJ˜J˜Kšœœ˜0Jšœ$˜$J˜Kšœ œ˜%J˜Jšœ$˜$Jšœ ˜ Jšœ˜Jšœ˜Jšœ ˜ Jšœ˜J˜Kšœ ˜ Kšœ˜Kšœ˜K˜K˜Kšœ˜Kšœ œ˜Kšœ˜Kšœ˜K˜K˜K˜ K˜Kšœ œ˜Kšœ ˜ Kšœ ˜ Kšœ˜K˜Kšœœ˜Kšœ œ˜Kšœœ˜Kšœœ˜ K˜Jšœ ˜ K˜—K˜š ž œœœ œœ˜:Jšœ˜Jšœ˜K˜K˜—Kšž œΟc˜FKšžœ˜+K˜—šœ™šžœœœ ˜šœœœ˜Kšœ˜Kšœœœœ˜(Kšœ˜—K˜—šžœœœ˜"Kš œœœœœ˜Kšœ˜"K˜K˜—šžœœœ ˜Kšœœ ˜'Kšœ&˜,K˜K˜—šžœœœ ˜Jšœ˜ Jšœ˜J˜—š žœœœœœ˜;šœœœ˜Kšœ˜Kšœœœ ˜Kšœ˜—K˜K˜—šžœ œœœ˜9Kšœœ ˜)Kšœ˜K˜——šž ™ šžœœœ ˜Kšœœ˜2Kšœœ˜4šœœœ˜Kšœ˜Kšœœœœ˜,Kšœ˜—K˜K˜—šžœœœ ˜Kšœœ ˜(šœœœ˜Kšœ˜Kšœœœœ ˜Kšœ˜—K˜J˜—šžœœœ ˜ Kšœœ˜2Kšœœ˜4šœœœ˜Kšœ˜Kšœœœœ˜-Kšœ˜—K˜J˜—šžœœœ ˜ Kšœœ˜2Kšœœ˜4šœœœ˜Kšœ˜Kšœœœœ˜-Kšœ˜—K˜J˜—šžœœœ ˜Kšœœ ˜(šœœœ˜Kšœ˜Kšœœœ˜!Kšœ˜—K˜J˜—šžœœœ ˜Kšœœ˜2Kšœœ˜4šœœœ˜Kšœ˜Kšœœœœ˜-Kšœ˜—K˜J˜——šœ ™ šžœœœ˜$Kšœœ ˜(šœ˜Kšœ œ˜Kšœ œ˜Kšœœ ˜—Jšœ˜J™—šžœœœ ˜Kšœœ ˜(šœœœ˜Kšœ˜Kšœœœ˜Kšœ˜—J˜J˜—šžœœœ˜&Kšœœ˜2Kšœœ˜4šœ ˜Kšœœ˜Kšœœ˜Kšœœ ˜—J˜J˜—šžœœœ˜Kšœœ˜2Kšœœ˜4Jšœ˜!J˜——˜J˜—Jšœ˜J˜J˜—…—Œc