
<<IPConvertImpl.mesa>>
<<Last edited by:>>
<<Doug Wyatt, April 29, 1983 2:17 pm>>

DIRECTORY
IPBasic USING [Any, Identifier, Integer, maxInteger, Number, Operator, Vector, zero],
IPConvert USING [IntegerToReal, NumberToInteger, NumberToReal],
IPErrors USING [MasterError, MasterWarning],
Real USING [Fix, RealException];

IPConvertImpl: CEDAR PROGRAM
IMPORTS IPConvert, IPErrors, Real
EXPORTS IPConvert
= BEGIN OPEN IPConvert, IPBasic;
<<>>
RealToInteger: PUBLIC PROC[r: REAL] RETURNS[Integer] = {
Fix: PROC[r: REAL] RETURNS[INT] = { RETURN[Real.Fix[r]] };
<<Wrap a procedure call around Real.Fix so we can catch RealException>>
i: INT = Fix[r ! Real.RealException => GOTO Fail];
IF i IN[0..maxInteger] AND i=r THEN RETURN[i] ELSE GOTO Fail;
EXITS Fail => ERROR IPErrors.MasterError[NarrowFailed];
};

AnyToNumber: PUBLIC PROC[x: Any] RETURNS[Number] = {
IF x.type=number THEN RETURN[x.number]
ELSE IF x.type=nil THEN { SIGNAL IPErrors.MasterWarning[NullValue]; RETURN[zero] }
ELSE ERROR IPErrors.MasterError[WrongType];
};
AnyToReal: PUBLIC PROC[x: Any] RETURNS[REAL] = {
IF x.type=number THEN RETURN[NumberToReal[x.number]]
ELSE IF x.type=nil THEN { SIGNAL IPErrors.MasterWarning[NullValue]; RETURN[0] }
ELSE ERROR IPErrors.MasterError[WrongType];
};
AnyToInteger: PUBLIC PROC[x: Any] RETURNS[Integer] = {
IF x.type=number THEN RETURN[NumberToInteger[x.number]]
ELSE IF x.type=nil THEN { SIGNAL IPErrors.MasterWarning[$NullValue]; RETURN[0] }
ELSE ERROR IPErrors.MasterError[WrongType];
};
AnyToIdentifier: PUBLIC PROC[x: Any] RETURNS[Identifier] = {
IF x.type=identifier THEN RETURN[NARROW[x.ref]]
ELSE ERROR IPErrors.MasterError[WrongType];
};
AnyToVector: PUBLIC PROC[x: Any] RETURNS[Vector] = {
IF x.type=vector THEN RETURN[x.ref]
ELSE ERROR IPErrors.MasterError[WrongType];
};
AnyToOperator: PUBLIC PROC[x: Any] RETURNS[Operator] = {
IF x.type=operator THEN RETURN[NARROW[x.ref]]
ELSE ERROR IPErrors.MasterError[WrongType];
};

NumberToAny: PUBLIC PROC[x: Number] RETURNS[Any] = {
RETURN[[type: number, number: x]];
};
RealToAny: PUBLIC PROC[x: REAL] RETURNS[Any] = {
RETURN[[type: number, number: [real[x]]]];
};
IntegerToAny: PUBLIC PROC[x: Integer] RETURNS[Any] = {
RETURN[[type: number, number: [int[x]]]];
};
IdentifierToAny: PUBLIC PROC[x: Identifier] RETURNS[Any] = {
RETURN[[type: identifier, ref: x]];
};
VectorToAny: PUBLIC PROC[x: Vector] RETURNS[Any] = {
RETURN[[type: vector, ref: x]];
};
OperatorToAny: PUBLIC PROC[x: Operator] RETURNS[Any] = {
RETURN[[type: operator, ref: x]];
};

END.