Types and Constants
IntsError: PUBLIC SIGNAL [reason: ATOM ← $Unspecified] = CODE;
bitsPerWord: CARDINAL = Basics.bitsPerWord;
CARD: TYPE = LONG CARDINAL;
ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
IntOne: Int ← FromINT[1];
IntZero: Int ← FromINT[0];
Variables
ClassPrintName:
AC.PrintNameProc = {
RETURN["Ints"];
};
ClassLegalFirstChar:
AC.LegalFirstCharOp = {
SELECT char
FROM
IN ['0..'9] => RETURN[TRUE];
ENDCASE;
RETURN[FALSE];
};
ClassRead:
AC.ReadOp = {
RETURN[Read[in]];
};
ClassFromRope:
AC.FromRopeOp = {
stream: IO.STREAM ← IO.RIS[in];
RETURN[ ClassRead[stream] ];
};
ClassToRope:
AC.ToRopeOp = {
RETURN[ ToRope[NARROW[in, Int] ] ]
};
ClassWrite:
AC.WriteOp = {
Write[stream, NARROW[in, Int] ]
};
ClassCharacteristic:
AC.StructureRankOp = {
RETURN[ 0 ]
};
ClassAdd:
AC.BinaryOp = {
RETURN[ Add[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassNegate:
AC.UnaryOp = {
RETURN[ Negate[ NARROW[arg, Int] ] ];
};
ClassSubtract:
AC.BinaryOp = {
RETURN[ Subtract[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassZero:
AC.NullaryOp = {
RETURN[ IntZero ]
};
ClassMultiply:
AC.BinaryOp = {
RETURN[ Multiply[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassRemainder:
AC.BinaryOp = {
RETURN[ Remainder[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassGcd:
AC.BinaryOp = {
RETURN[ Gcd[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassOne:
AC.NullaryOp = {
RETURN[ IntOne ]
};
ClassEqual:
AC.EqualityOp = {
RETURN[ Equal[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
ClassSign:
AC.CompareToZeroOp = {
RETURN[ Sign[NARROW[arg, Int] ] ]
};
ClassAbs:
AC.UnaryOp = {
RETURN[ Abs[NARROW[arg, Int] ] ]
};
ClassCompare:
AC.BinaryCompareOp = {
RETURN[ Compare[NARROW[firstArg, Int], NARROW[secondArg, Int] ] ]
};
IntClass:
AC.StructureClass ←
NEW[
AC.StructureClassRec ← [
flavor: ring,
printName: ClassPrintName,
characteristic: ClassCharacteristic,
legalFirstChar: ClassLegalFirstChar,
read: ClassRead,
fromRope: ClassFromRope,
toRope: ClassToRope,
write: ClassWrite,
add: ClassAdd,
negate: ClassNegate,
subtract: ClassSubtract,
zero: ClassZero,
multiply: ClassMultiply,
commutative: TRUE,
one: ClassOne,
equal: ClassEqual,
ordered: TRUE,
sign: ClassSign,
abs: ClassAbs,
compare: ClassCompare,
integralDomain: TRUE,
gcdDomain: TRUE,
gcd: ClassGcd,
euclideanDomain: TRUE,
remainder: ClassRemainder,
propList: NIL
] ];
Ints:
PUBLIC
AC.Structure ←
NEW[
AC.StructureRec ← [
class: IntClass,
instanceData: NIL
] ];
I/O and Conversion
Read:
PUBLIC
PROC [in:
IO.
STREAM]
RETURNS [out: Int] ~ {
RETURN[NEW[IntRep ← [IO.GetInt[in] ] ] ];
};
FromRope:
PUBLIC
PROC [rope:
ROPE]
RETURNS [Int] = {
RETURN[NEW[IntRep ← [Convert.IntFromRope[rope] ] ] ];
};
ToRope:
PUBLIC
PROC [int: Int]
RETURNS [out:
ROPE] = {
RETURN[ Convert.RopeFromInt[int.val] ];
};
Write:
PUBLIC
PROC [stream:
IO.
STREAM, in: Int] = {
IO.PutRope[ stream, ToRope[in] ]
};
FromINT:
PUBLIC
PROC [int:
INT]
RETURNS [Int] = {
RETURN[NEW[IntRep ← [int] ] ];
};
ToINT:
PUBLIC PROC [int: Int]
RETURNS [
INT] = {
RETURN[int.val];
};
Arithmetic
Add:
PUBLIC
PROC [firstArg, secondArg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [firstArg.val + secondArg.val]]];
};
Negate:
PUBLIC
PROC [arg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [ - arg.val]]];
};
Subtract:
PUBLIC
PROC [firstArg, secondArg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [firstArg.val - secondArg.val]]];
};
Multiply:
PUBLIC
PROC [firstArg, secondArg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [firstArg.val * secondArg.val]]];
};
Remainder:
PUBLIC
PROC [firstArg, secondArg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [firstArg.val MOD secondArg.val]]];
};
Gcd:
PUBLIC
PROC [m, n: Int]
RETURNS [gcd: Int] ~ {
Euclidean algorithm, adapted from Mesa manual p. 2-2
IF Equal[m, IntZero] AND Equal[n, IntZero] THEN gcd ← IntZero
ELSE {
r: Int;
UNTIL Equal[n, IntZero]
DO
r ← Remainder[m, n];
m ← n; n ← r;
ENDLOOP;
gcd ← Abs[m];
};
};
Comparison
Sign:
PUBLIC
PROC [arg: Int]
RETURNS [Basics.Comparison] = {
SELECT arg.val
FROM
< 0 => RETURN[less];
= 0 => RETURN[equal];
ENDCASE => RETURN[greater];
};
Abs:
PUBLIC
PROC [arg: Int]
RETURNS [result: Int] ~ {
RETURN [NEW[IntRep ← [ ABS[arg.val] ]]];
};
Compare:
PUBLIC PROC [firstArg, secondArg: Int]
RETURNS [Basics.Comparison] ~ {
SELECT firstArg.val
FROM
< secondArg.val => RETURN[less];
= secondArg.val => RETURN[equal];
ENDCASE => RETURN[greater];
};
Equal:
PUBLIC PROC [firstArg, secondArg: Int]
RETURNS [
BOOL] ~ {
RETURN[ Compare[firstArg, secondArg] = equal ]
};