-- LupineTypeTest.mesa.
-- Copyright (C) 1985 by Xerox Corporation. All rights reserved.
-- Last edited by BZM on 12-May-82 19:24:14.
-- Bob Hagmann February 8, 1985 5:10:11 pm PST


DIRECTORY

BasicTime USING [Unpacked],
Rope USING [ROPE],
RPC USING [Conversation, ShortSTRING, ShortROPE];


LupineTypeTest: DEFINITIONS =
BEGIN


-- Types.

ROPE: TYPE = Rope.ROPE;

Color: TYPE = {red, green, yellow};
ColorRange: TYPE = [1..3];
Intensity: TYPE = [0..127);

HANDLE: TYPE = PRIVATE HANDLEPtr; HANDLEPtr: TYPE = POINTER;

ProcType: TYPE = HANDLEProcType;
HANDLEProcType: TYPE = PROCEDURE [one: STRING, two: HANDLE]
RETURNS [more: BOOLEAN];

ExportObject: TYPE [1];
ExportHandle: TYPE = POINTER TO ExportObject;

Zone: TYPE = HANDLEZone; HANDLEZone: TYPE = ZONE;
UncountedZone: TYPE = HANDLEUZone; HANDLEUZone: TYPE = UNCOUNTED ZONE;
MdsZone: TYPE = HANDLEMDSZone; HANDLEMDSZone: TYPE = MDSZone;

ComputedVariant: TYPE = RECORD [
 oddPart: SELECT OVERLAID * FROM
  num => [INTEGER],
  flags => [SELECT COMPUTED {flags} FROM
   flags => [f: PACKED ARRAY CHARACTER OF BOOLEAN],
   ENDCASE ],
  ENDCASE ];

SmallVariant: TYPE = RECORD [
 handle: HANDLE,
 oddPart: SELECT varTag: * FROM
  test => [r: ROPE],
  empty => [],
  plain => [c: CARDINAL, r: REAL],
  ENDCASE ];

BigVariant: TYPE = RECORD [
 common: INTEGER,
 plain: PACKED ARRAY [1..64] OF CHARACTER,
 variant: SELECT varTag: * FROM
  list => [l: LIST OF REF TEXT],
  handle => [h, i, j: HANDLE],
  empty => [],
  plain => [c: CARDINAL, r: REAL],
  small => [fill: BOOLEAN, smallVar: SmallVariant],
  spectrum => [
  SELECT color: Color FROM
  yellow => [contrast: REF READONLY Intensity],
  red => [desc: LONG DESCRIPTOR FOR READONLY ARRAY OF RECORD [
   colorName: STRING,
   brilliance: Intensity] ],
  green => [empty: BOOLEAN],
  ENDCASE ],
  ENDCASE ];

Space: TYPE = PACKED ARRAY BOOLEAN OF ARRAY [1..7] OF REF SpaceRecord;
SpaceRecord: TYPE = RECORD [
 bits: DESCRIPTOR FOR PACKED ARRAY [2000..2010] OF BOOLEAN,
 colors: PACKED SEQUENCE range: ColorRange OF Intensity ];

ReadonlyString: TYPE = REF READONLY StringBody;
TestRecord: TYPE = RECORD [
 one: REF ReadonlyString,
 two: RECORD [block: ARRAY [0..4) OF LONG CARDINAL],
 three: LONG DESCRIPTOR FOR PACKED ARRAY OF Intensity ];

FiniteSequence: TYPE = RECORD [SEQUENCE range: ColorRange OF REF REAL];

PublicConv, PrivateConv: TYPE = HANDLEConversation;
HANDLEConversation: TYPE = RPC.Conversation;

RNameList: TYPE = LONG POINTER TO READONLY RNameListObject;
RNameListObject: TYPE = RECORD [
names: PACKED SEQUENCE length: [0..64] OF LONG RPC.ShortSTRING ];

Group: TYPE = RECORD [owners: RNameList, total: LONG INTEGER];

Int: TYPE = LONG POINTER TO LONG INTEGER;
HANDLEInt: TYPE = Int;
VALUEInt: TYPE = Int;
VARInt: TYPE = Int;
RESULTInt: TYPE = Int;

String: TYPE = STRING;
HANDLEString: TYPE = String;
VALUEString: TYPE = String;
VARString: TYPE = String;
RESULTString: TYPE = String;

Buffer: TYPE = LONG DESCRIPTOR FOR ARRAY OF WORD;
HANDLEBuffer: TYPE = Buffer;
VALUEBuffer: TYPE = Buffer;
VARBuffer: TYPE = Buffer;
RESULTBuffer: TYPE = Buffer;


-- Interface Exceptions.

PlainError: ERROR;

ArgError: ERROR [type: Color, position: CARDINAL];

PlainSignal: SIGNAL;

ArgSignal: SIGNAL [bogus: Color];

ResultSignal: SIGNAL RETURNS [resume: BOOLEAN];

AnonSignal: SIGNAL [now, later: BOOLEAN, text: POINTER TO READONLY TEXT]
RETURNS [BOOLEAN, BOOLEAN, POINTER TO READONLY TEXT];

FullSignal: SIGNAL [check: ProcType] RETURNS [use: Color];

ComplexSignal: SIGNAL [
 nat: NAT,
 refTime: REF BasicTime.Unpacked ]
RETURNS [
 atom: ATOM,
 list: LIST OF ATOM ];



-- Interface Procedures.

InlineCheck: PROCEDURE = INLINE {};

MachineCheck: PROCEDURE = MACHINE CODE {};

PlainProc: PROCEDURE;

ArgProc: PROCEDURE [number: CARDINAL, string: STRING];

ResProc: PROCEDURE RETURNS [block: ARRAY [0..4) OF INTEGER];

FullProc: PROCEDURE [input: BOOLEAN] RETURNS [output: CHARACTER];

BigProc: PROCEDURE [
 firstOne: BOOLEAN,
 ptr: LONG POINTER TO INTEGER,
 tooBig: ARRAY [0..300) OF BOOLEAN,
 willFit: ARRAY [0..200) OF BOOLEAN,
 str1: STRING,
 fitsToo: ARRAY [0..40) OF BOOLEAN,
 noDice: ARRAY [0..40) OF BOOLEAN,
 yep: BOOLEAN,
 fillsItUp: ARRAY [0..13) OF BOOLEAN,
 -- These next three don't fit into the overlay and should
 -- be copied, uninterpreted, into the second packet.
 stringHandle: HANDLEString,
 intHandle: HANDLEInt,
 descHandle: HANDLEBuffer,
 str2: STRING ];

CedarProc: PROC [
 nat: NAT,
 refInt: REF INTEGER,
 refAny: REF ]
RETURNS [
 body: REF StringBody,
 rope: REF READONLY TEXT,
 shortRope: RPC.ShortROPE,
 zone: Zone,
 list: LIST OF ARRAY Color OF LIST OF ATOM,
 finiteSeq: REF FiniteSequence ];
  
AnonProc: PROCEDURE [i: INTEGER, p: ProcType, h: HANDLE, u: BasicTime.Unpacked]
RETURNS [LONG INTEGER, LIST OF ZONE];

ZoneCheck: PROCEDURE [cedar: Zone, heap: UncountedZone] RETURNS [mds: MdsZone];

Test: PROCEDURE [input: BOOLEAN, array: ARRAY [0..10] OF TestRecord]
RETURNS [char: CHARACTER];

ConversationTest: PROCEDURE [doThis: PublicConv, skipThis: PrivateConv]
RETURNS [skipThisToo: PublicConv];


ProcParam: PROCEDURE [proc: ProcType];

ExportTest: PROCEDURE [object: ExportObject]
RETURNS [approved: ExportHandle, notApproved: HANDLE];

Array: PROC [ok: LONG CARDINAL, space: REF Space] RETURNS [real: REF REAL];


VarInt: PROCEDURE [
var: VARInt, val: VALUEInt, res: RESULTInt, han: HANDLEInt ];

VarString: PROCEDURE [
var: VARString, val: VALUEString, res: RESULTString, han: HANDLEString ];

VarBuffer: PROCEDURE [
var: VARBuffer, val: VALUEBuffer, res: RESULTBuffer, han: HANDLEBuffer ];


END. -- LupineTypeTest.


StringConvert: PROCEDURE [
StoR, RtoA, AtoS: BOOLEAN,
string: RPC.ShortSTRING,
rope: RPC.ShortROPE,
atom: RPC.ShortATOM ]
RETURNS [
longString: LONG STRING,
longRope: ROPE,
longAtom: ATOM ];

MakeList: PROCEDURE [individuals: LIST OF RPC.ShortROPE] RETURNS [RNameList];

CheckName: PROCEDURE [name: RPC.ShortSTRING, group: Group] RETURNS [BOOLEAN];

TestVariants: PROCEDURE [
 smallone: DESCRIPTOR FOR ARRAY OF SmallVariant,
 two: LONG CARDINAL ]
RETURNS [
 char: CHARACTER,
 big: REF BigVariant ];

TestVariants: PROCEDURE [
 smallone: DESCRIPTOR FOR READONLY ARRAY OF SmallVariant,
 two: LONG CARDINAL ]
RETURNS [
 char: CHARACTER
--big: REF BigVariant-- ];

Bob Hagmann February 8, 1985 5:10:12 pm PST