DIRECTORY Commander, GenericCall, IO;

GenericCallImpl: PROGRAM
IMPORTS Commander, IO
EXPORTS GenericCall =
BEGIN OPEN GenericCall;

Unimplemented: PUBLIC ERROR = CODE;
BadArgs: PUBLIC ERROR = CODE;

Word: TYPE ~ CARD;
PointerFitsInWord: BOOL[TRUE..TRUE] ~ (BITS[POINTER] <= BITS[Word]);

Words: TYPE ~ REF WordSeq;
WordSeq: TYPE ~ RECORD [words: SEQUENCE size: NAT OF Word];

RecordLayout: TYPE ~ RECORD [
words: NAT,
ws: Words,
pa: POINTER TO ARRAY [0..maxDirectCedarArgWords-1] OF Word,
fields: ArgFields];

ArgFields: TYPE ~ REF ArgFieldSeq;
ArgFieldSeq: TYPE ~ RECORD [SEQUENCE length: NAT OF ArgField];

ArgField: TYPE ~ RECORD [
address: Pointer,
bitOffset: Size,
bits: Size,
variant: SELECT kind: * FROM
direct => [],
indirect => [ws: Words, bitOffset2: Size, bits2: Size],
ENDCASE];

PM: PROC [p: POINTER] RETURNS [Pointer]
~ INLINE {RETURN [LOOPHOLE[p]]};

MP: PROC [p: Pointer] RETURNS [POINTER]
~ INLINE {RETURN [LOOPHOLE[p]]};

CM: PROC [c: CARD] RETURNS [Pointer]
~ INLINE {RETURN [c]};

IM: PROC [i: INT] RETURNS [Pointer]
~ INLINE {RETURN [LOOPHOLE[i]]};

NcM: PROC [c: CARD] RETURNS [Pointer]
~ INLINE {RETURN [c]};

NiM: PROC [i: INT] RETURNS [Pointer]
~ INLINE {RETURN [LOOPHOLE[i]]};

maxDirectCedarArgWords: NAT ~ 16;
maxDirectCedarRetWords: NAT ~ 1;

Call: PUBLIC PROC [proc: ProcRep, formalArgSizes, formalRetSizes: SizeList, actualArgs, actualRets: Fields] ~ {
formalArgLay: RecordLayout ~ Layout[formalArgSizes, actualArgs.length, maxDirectCedarArgWords, TRUE];
formalRetLay: RecordLayout ~ Layout[formalRetSizes, actualRets.length, maxDirectCedarRetWords, FALSE];
indirectCedarArgs: BOOL ~ formalArgLay.words > maxDirectCedarArgWords;
indirectCedarRets: BOOL ~ formalRetLay.words > maxDirectCedarRetWords;
nested: BOOL ~ SELECT proc.flag FROM CM[0] => FALSE, CM[1] => TRUE, ENDCASE => ERROR;
argCopy: RecordLayout _ formalArgLay;
retCopy: RecordLayout _ formalRetLay;
CopyRecord[Argify[actualArgs], formalArgLay.fields];
SELECT TRUE FROM
nested AND indirectCedarArgs AND indirectCedarRets => {
Local: PROC [retPtr, argPtr: POINTER] ~ LOOPHOLE[proc];
Local[formalRetLay.pa, formalArgLay.pa]};
nested AND indirectCedarArgs AND ~indirectCedarRets => {
Local: PROC [argPtr: POINTER] RETURNS [Word] ~ LOOPHOLE[proc];
formalRetLay.pa[0] _ Local[formalArgLay.pa]};
nested AND ~indirectCedarArgs AND indirectCedarRets => {
Local: PA16R2T ~ LOOPHOLE[proc];
ra: POINTER TO ARRAY [0..1] OF Word ~ LOOPHOLE[formalRetLay.pa];
IF formalArgLay.words < maxDirectCedarArgWords THEN formalArgLay.pa[formalArgLay.words] _ LOOPHOLE[Local];
ra^ _ Local[formalArgLay.pa[0], formalArgLay.pa[1], formalArgLay.pa[2], formalArgLay.pa[3], formalArgLay.pa[4], formalArgLay.pa[5], formalArgLay.pa[6], formalArgLay.pa[7], formalArgLay.pa[8], formalArgLay.pa[9], formalArgLay.pa[10], formalArgLay.pa[11], formalArgLay.pa[12], formalArgLay.pa[13], formalArgLay.pa[14], formalArgLay.pa[15] ]};
nested AND ~indirectCedarArgs AND ~indirectCedarRets => {
Local: PA16R1T ~ LOOPHOLE[proc];
IF formalArgLay.words < maxDirectCedarArgWords THEN formalArgLay.pa[formalArgLay.words] _ LOOPHOLE[Local];
formalRetLay.pa[0] _ Local[formalArgLay.pa[0], formalArgLay.pa[1], formalArgLay.pa[2], formalArgLay.pa[3], formalArgLay.pa[4], formalArgLay.pa[5], formalArgLay.pa[6], formalArgLay.pa[7], formalArgLay.pa[8], formalArgLay.pa[9], formalArgLay.pa[10], formalArgLay.pa[11], formalArgLay.pa[12], formalArgLay.pa[13], formalArgLay.pa[14], formalArgLay.pa[15] ]};
~nested AND indirectCedarArgs AND indirectCedarRets => {
(LOOPHOLE[proc, PROC [retPtr, argPtr: POINTER]])[formalRetLay.pa, formalArgLay.pa]};
~nested AND indirectCedarArgs AND ~indirectCedarRets => {
formalRetLay.pa[0] _ (LOOPHOLE[proc, PROC [argPtr: POINTER] RETURNS [Word] ])[ formalArgLay.pa ]};
~nested AND ~indirectCedarArgs AND indirectCedarRets => {
ra: POINTER TO ARRAY [0..1] OF Word ~ LOOPHOLE[formalRetLay.pa];
IF formalArgLay.words < maxDirectCedarArgWords THEN formalArgLay.pa[formalArgLay.words] _ LOOPHOLE[proc];
ra^ _ (LOOPHOLE[proc, PA16R2T])[formalArgLay.pa[0], formalArgLay.pa[1], formalArgLay.pa[2], formalArgLay.pa[3], formalArgLay.pa[4], formalArgLay.pa[5], formalArgLay.pa[6], formalArgLay.pa[7], formalArgLay.pa[8], formalArgLay.pa[9], formalArgLay.pa[10], formalArgLay.pa[11], formalArgLay.pa[12], formalArgLay.pa[13], formalArgLay.pa[14], formalArgLay.pa[15] ]};
~nested AND ~indirectCedarArgs AND ~indirectCedarRets => {
IF formalArgLay.words < maxDirectCedarArgWords THEN formalArgLay.pa[formalArgLay.words] _ LOOPHOLE[proc];
formalRetLay.pa[0] _ (LOOPHOLE[proc, PA16R1T])[ formalArgLay.pa[0], formalArgLay.pa[1], formalArgLay.pa[2], formalArgLay.pa[3], formalArgLay.pa[4], formalArgLay.pa[5], formalArgLay.pa[6], formalArgLay.pa[7], formalArgLay.pa[8], formalArgLay.pa[9], formalArgLay.pa[10], formalArgLay.pa[11], formalArgLay.pa[12], formalArgLay.pa[13], formalArgLay.pa[14], formalArgLay.pa[15] ]};
ENDCASE => ERROR;
CopyRecord[formalRetLay.fields, Argify[actualRets]];
RETURN};

Layout: PROC [sizes: SizeList, length, minWs: NAT, mayIndirect: BOOL] RETURNS [RecordLayout] ~ {
fields: ArgFields ~ NEW [ArgFieldSeq[length]];
wc: Size _ 0;
k: NAT _ 0;
FOR sl: SizeList _ sizes, sl.rest WHILE sl#NIL DO
bts: Size ~ sl.first;
wds: Size _ (bts+bitsPerWord-1)/bitsPerWord;
SELECT TRUE FROM
wds=0 => ERROR BadArgs;
wds=1 => fields[k] _ [NcM[wc*unitsPerWord], bitsPerWord-bts, bts, direct[]];
NOT mayIndirect => fields[k] _ [NcM[wc*unitsPerWord], 0, bts, direct[]];
ENDCASE => {
ws: Words ~ NEW[WordSeq[wds]];
FOR i: Size IN [0..ws.size) DO ws[i] _ 0 ENDLOOP;
fields[k] _ [NcM[wc*unitsPerWord], 0, bitsPerWord, indirect[ws, 0, bts]];
wds _ 1};
wc _ wc + wds;
k _ k + 1;
ENDLOOP;
IF k # length THEN ERROR;
{ws: Words ~ NEW[WordSeq[MAX[minWs, wc]]];
base: Pointer--will have to change when Pointer becomes POINTER-- ~ LOOPHOLE[@ws[0]];
FOR i: Size IN [0..ws.size) DO ws[i] _ 0 ENDLOOP;
FOR j: NAT IN [0..fields.length) DO
fields[j].address _ fields[j].address + base;
WITH fields[j] SELECT FROM
x: direct ArgField => NULL;
x: indirect ArgField => MP[fields[j].address]^ _ @x.ws[0];
ENDCASE => ERROR;
ENDLOOP;
RETURN [[wc, ws, LOOPHOLE[base], fields]]}};

RawWords: TYPE ~ RECORD [SEQUENCE COMPUTED CARD OF Word];
RawBits: TYPE ~ RECORD [PACKED SEQUENCE COMPUTED CARD OF BOOL];

CopyRecord: PROC [from, to: ArgFields] ~ {
IF from.length # to.length THEN ERROR;
FOR i: NAT IN [0 .. from.length) DO
ff: Field ~ Fieldify[from[i]];
tf: Field ~ Fieldify[to[i]];
IF ff.bits # tf.bits THEN ERROR;
IF tf.bitOffset=ff.bitOffset THEN {
fp: LONG POINTER TO RawWords ~ LOOPHOLE[ff.address];
tp: LONG POINTER TO RawWords ~ LOOPHOLE[tf.address];
wds: Size ~ (ff.bits+ff.bitOffset+bitsPerWord-1)/bitsPerWord;
FOR j: Size IN [0..wds) DO tp[j] _ fp[j] ENDLOOP;
}
ELSE {
fp: LONG POINTER TO RawBits ~ LOOPHOLE[ff.address];
tp: LONG POINTER TO RawBits ~ LOOPHOLE[tf.address];
fi: CARD _ ff.bitOffset;
FOR ti: CARD IN [tf.bitOffset..tf.bitOffset+tf.bits) DO
tp[ti] _ fp[fi];
fi _ fi.SUCC;
ENDLOOP;
};
ENDLOOP;
RETURN};

Fieldify: PROC [af: ArgField] RETURNS [Field] ~ {
WITH af SELECT FROM
direct => RETURN [[address, bitOffset, bits]];
indirect => RETURN [[PM[@ws[0]], bitOffset2, bits2]];
ENDCASE => ERROR};

Argify: PROC [fs: Fields] RETURNS [afs: ArgFields] ~ {
afs _ NEW [ArgFieldSeq[fs.length]];
FOR i: NAT IN [0 .. fs.length) DO
afs[i] _ [fs[i].address, fs[i].bitOffset, fs[i].bits, direct[]];
ENDLOOP;
RETURN};

Seqifields: PUBLIC PROC [fl: FieldList] RETURNS [fs: Fields] ~ {
length, i: NAT _ 0;
FOR flt: FieldList _ fl, flt.rest WHILE flt#NIL DO length _ length+1 ENDLOOP;
fs _ NEW [FieldSeq[length]];
FOR fl _ fl, fl.rest WHILE fl#NIL DO fs[i] _ fl.first; i _ i+1 ENDLOOP;
RETURN};

ListCall: PROC [proc: ProcRep, formalArgSizes, formalRetSizes: SizeList, actualArgs, actualRets: FieldList] ~ {
Call[proc, formalArgSizes, formalRetSizes, Seqifields[actualArgs], Seqifields[actualRets]];
RETURN};

WordPair: TYPE ~ RECORD [e0, e1: Word];
BitPair: TYPE ~ RECORD [e0, e1: BOOL];
PackedBitPair: TYPE ~ MACHINE DEPENDENT RECORD [e0, e1: BOOL];
PBQ: TYPE ~ PACKED RECORD [p0, p1: PackedBitPair];
EmptyWords: TYPE ~ RECORD [];
MixedWords: TYPE ~ RECORD [w1: Word, e2: EmptyWords, w3: Word];

PA16R0T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word];
PA17R0T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17: Word];
PA15R1T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15: Word] RETURNS [Word];
PA16R1T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [Word];
PA17R1T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17: Word] RETURNS [Word];
PA15R2T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15: Word] RETURNS [ARRAY [0..1] OF Word];
PA16R2T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [ARRAY [0..1] OF Word];
PA17R2T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17: Word] RETURNS [ARRAY [0..1] OF Word];
PA16dT: TYPE ~ PROC [a1, a2, a3, a4: Word, a56: WordPair, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [Word];
PAMRMT: TYPE ~ PROC [a1: Word, a23: WordPair, a45: BitPair, a67, a89: PackedBitPair] RETURNS [r1: Word, r23: WordPair, r45: BitPair, r67, r89: PackedBitPair];
PA16R4T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [ARRAY [0..4) OF Word];
PA16R16T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [ARRAY [0..16) OF Word];
PA16R64T: TYPE ~ PROC [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [ARRAY [0..64) OF Word];

Demo: Commander.CommandProc ~ TRUSTED {
in: IO.STREAM ~ IO.RIS[cmd.commandLine];
key: REF ANY _ NIL;
w2: ARRAY [0..1] OF Word;
v2: ARRAY [0..1] OF Word _ [1, 2];
u2: ARRAY [0..1] OF Word _ [3, 4];
t2: ARRAY [0..1] OF Word _ [837, 17701];
x, y: Word _ 47;
b2A: BitPair _ [TRUE, FALSE];
b2B: BitPair _ [TRUE, FALSE];
pbX: PackedBitPair _ [FALSE, TRUE];
pbY: PackedBitPair _ [TRUE, FALSE];
pbW: PackedBitPair _ [FALSE, FALSE];
pbZ: PackedBitPair _ [TRUE, TRUE];
ary17: ARRAY [1..17] OF CARDINAL _ ALL[0];
LPA16R0V: PA16R0T ~ {x _ a16};
LPA17R0V: PA17R0T ~ {x _ a17};
LPA15R1V: PA15R1T ~ {RETURN [a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15]};
LPA16R1V: PA16R1T ~ {RETURN [a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15+a16]};
LPA17R1V: PA17R1T ~ {RETURN [a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15+a16+a17]};
LPA15R2V: PA15R2T ~ {RETURN [[a1, a15]]};
LPA16R2V: PA16R2T ~ {RETURN [[a1, a16]]};
LPA17R2V: PA17R2T ~ {RETURN [[a1, a17]]};
LPA17R2Vb: PA17R2T ~ {RETURN [[10, v2[0]]]};
LPA16dV: PA16dT ~ {RETURN [a1+a56.e1+a16]};
LPAMRMV: PAMRMT ~ {RETURN [v2[1], [t2[0], t2[1]], [a67.e0, a67.e1], [a45.e0, a45.e1], a89]};
sa17: SizeList _ NIL;
key _ in.GetRefAny[!IO.Error, IO.EndOfStream => CONTINUE];
IF key=NIL THEN RETURN [$Failure, "Usage: GenericCallDemo $key"];
FOR i: NAT IN [1..17] DO ary17[i] _ i; sa17 _ CONS[BITS[Word], sa17] ENDLOOP;
w2 _ LPA17R2V[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 16];
LPA16R0V[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3];
[x, [w2[0], w2[1]]] _ PAMRMV[x, [13, v2[1]], [FALSE, TRUE], [TRUE, FALSE], [FALSE, TRUE]];
SELECT key FROM
$la17r2 => {
ListCall[
LOOPHOLE[LPA17R2V],
sa17, 
LIST[2*BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32], [PM[@ary17[17]],  0, 32] ],
LIST[[PM[@u2], 0, 64]] ];
cmd.out.PutFL["After LPA17R2V, u2=[%g, %g] (should=[1, 17])\n", LIST[ [cardinal[u2[0]]], [cardinal[u2[1]]] ]];
};
$la17r1 => {
ListCall[
LOOPHOLE[LPA17R1V],
sa17, 
LIST[BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32], [PM[@ary17[17]],  0, 32] ],
LIST[[PM[@x], 0, 32]] ];
cmd.out.PutFL["After LPA17R1V, x=%g (should=153)\n", LIST[ [cardinal[x]] ]];
};
$la16r1 => {
ListCall[
LOOPHOLE[LPA16R1V],
sa17.rest, 
LIST[BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32] ],
LIST[[PM[@x], 0, 32]] ];
cmd.out.PutFL["After LPA16R1V, x=%g (should=136)\n", LIST[ [cardinal[x]] ]];
};
$lamrm => {
cmd.out.PutFL["Before PAMRMV, v2[1]=%g, t2=[%g, %g], b2A=[%g, %g], pbX=[%g, %g]\n", LIST[ [cardinal[v2[1]]], [cardinal[t2[0]]], [cardinal[t2[1]]], [boolean[b2A.e0]], [boolean[b2A.e1]], [boolean[pbX.e0]], [boolean[pbX.e1]] ]];
ListCall[
LOOPHOLE[LPAMRMV],
LIST[BITS[Word], BITS[WordPair], BITS[BitPair], BITS[PackedBitPair], BITS[PackedBitPair]],
LIST[BITS[Word], BITS[WordPair], BITS[BitPair], BITS[PackedBitPair], BITS[PackedBitPair]],
LIST[[PM[@x], 0, 32], [PM[@v2], 0, 64], [PM[@b2A], 0, 64], [PM[@pbX], 30, 2], [PM[@pbY], 30, 2]],
LIST[[PM[@y], 0, 32], [PM[@u2], 0, 64], [PM[@b2B], 0, 64], [PM[@pbW], 30, 2], [PM[@pbZ], 30, 2]] ];
cmd.out.PutFL["After LPAMRMV, y=%g, u2=[%g, %g], b2B=[%g, %g], pbW=[%g, %g]\n", LIST[ [cardinal[y]], [cardinal[u2[0]]], [cardinal[u2[1]]], [boolean[b2B.e0]], [boolean[b2B.e1]], [boolean[pbW.e0]], [boolean[pbW.e1]] ]];
};
$ga17r2 => {
ListCall[
LOOPHOLE[PA17R2V],
sa17, 
LIST[2*BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32], [PM[@ary17[17]],  0, 32] ],
LIST[[PM[@u2], 0, 64]] ];
cmd.out.PutFL["After PA17R2V, u2=[%g, %g] (should=[3, 33])\n", LIST[ [cardinal[u2[0]]], [cardinal[u2[1]]] ]];
};
$ga17r1 => {
ListCall[
LOOPHOLE[PA17R1V],
sa17, 
LIST[BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32], [PM[@ary17[17]],  0, 32] ],
LIST[[PM[@y], 0, 32]] ];
cmd.out.PutFL["After PA17R1V, y=%g (should=18)\n", LIST[ [cardinal[y]] ]];
};
$ga16r1 => {
ListCall[
LOOPHOLE[PA16R1V],
sa17.rest, 
LIST[BITS[Word]],
LIST[[PM[@ary17[1]], 0, 32], [PM[@ary17[2]],  0, 32], [PM[@ary17[3]], 0, 32], [PM[@ary17[4]],  0, 32], [PM[@ary17[5]], 0, 32], [PM[@ary17[6]],  0, 32], [PM[@ary17[7]], 0, 32], [PM[@ary17[8]],  0, 32], [PM[@ary17[9]], 0, 32], [PM[@ary17[10]],  0, 32], [PM[@ary17[11]], 0, 32], [PM[@ary17[12]],  0, 32], [PM[@ary17[13]], 0, 32], [PM[@ary17[14]],  0, 32], [PM[@ary17[15]], 0, 32], [PM[@ary17[16]],  0, 32] ],
LIST[[PM[@y], 0, 32]] ];
cmd.out.PutFL["After PA16R1V, y=%g (should=34)\n", LIST[ [cardinal[y]] ]];
};
$gamrm => {
cmd.out.PutFL["Before PAMRMV, x=%g, v2=[%g, %g], b2A=[%g, %g], pbX=[%g, %g]\n", LIST[ [cardinal[x]], [cardinal[v2[0]]], [cardinal[v2[1]]], [boolean[b2A.e0]], [boolean[b2A.e1]], [boolean[pbX.e0]], [boolean[pbX.e1]] ]];
ListCall[
LOOPHOLE[PAMRMV],
LIST[BITS[Word], BITS[WordPair], BITS[BitPair], BITS[PackedBitPair], BITS[PackedBitPair]],
LIST[BITS[Word], BITS[WordPair], BITS[BitPair], BITS[PackedBitPair], BITS[PackedBitPair]],
LIST[[PM[@x], 0, 32], [PM[@v2], 0, 64], [PM[@b2A], 0, 64], [PM[@pbX], 30, 2], [PM[@pbY], 30, 2]],
LIST[[PM[@y], 0, 32], [PM[@u2], 0, 64], [PM[@b2B], 0, 64], [PM[@pbW], 30, 2], [PM[@pbZ], 30, 2]] ];
cmd.out.PutFL["After PAMRMV, x=%g, v2=[%g, %g], b2A=[%g, %g], pbX=[%g, %g]\n", LIST[ [cardinal[x]], [cardinal[v2[0]]], [cardinal[v2[1]]], [boolean[b2A.e0]], [boolean[b2A.e1]], [boolean[pbX.e0]], [boolean[pbX.e1]] ]];
cmd.out.PutFL["After PAMRMV, y=%g, u2=[%g, %g], b2B=[%g, %g], pbW=[%g, %g]\n", LIST[ [cardinal[y]], [cardinal[u2[0]]], [cardinal[u2[1]]], [boolean[b2B.e0]], [boolean[b2B.e1]], [boolean[pbW.e0]], [boolean[pbW.e1]] ]];
};
ENDCASE => cmd.out.PutRope["$key should be one of: $la17r2, $la17r1, $la16r1, $lamrm, $ga17r2, $ga17r1, $ga16r1, $gamrm.\n"];
RETURN};

PA16R0V: PA16R0T ~ {mw.w1 _ a16};
PA17R0V: PA17R0T ~ {mw.w1 _ a17};
PA15R1V: PA15R1T ~ {RETURN [a1+a15]};
PA16R1V: PA16R1T ~ {RETURN [a1+a2+a15+a16]};
PA17R1V: PA17R1T ~ {RETURN [a1+a17]};
PA15R2V: PA15R2T ~ {RETURN [[a1, a15]]};
PA16R2V: PA16R2T ~ {RETURN [[a1, a16]]};
PA17R2V: PA17R2T ~ {RETURN [[a1+a2, a16+a17]]};
PA16dV: PA16dT ~ {RETURN [a1+a56.e1+a16]};
PAMRMV: PAMRMT ~ {RETURN [a23.e0, [a23.e1, a1], [a67.e0, a67.e1], [a45.e0, a45.e1], a89]};
mw: MixedWords _ [7, [], 3];

Commander.Register["GenericCallDemo", Demo, "- for internal use only"];

END.
X
GenericCallImpl.mesa
Last tweaked by Mike Spreitzer on December 18, 1989 4:31:07 pm PST
Use this instead of CM when syntactic type of actual arg is INT and arg is expected to be fit in NAT; the call effects the bounds check.
Use this instead of IM when syntactic type of actual arg is CARD and arg is expected to be fit in NAT; the call effects the bounds check.
PA16eT: TYPE ~ PROC [a1, a2, a3, a4: Word, a5: EmptyWords, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16: Word] RETURNS [Word];
PA17eT: TYPE ~ PROC [a1, a2, a3, a4: Word, a5: EmptyWords, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17: Word] RETURNS [Word];
PA1RMT: TYPE ~ PROC [a1: Word] RETURNS [w1: Word, e2: EmptyWords, w3: Word];
v2 _ LPA17R2Vb[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 16];
PA16eV: PA16eT ~ {RETURN [a1+a16]};
PA17eV: PA17eT ~ {RETURN [a1+a17]};
Κ?–

"cedar" style•NewlineDelimiter

™™Icode™B—K˜KšΟk	œœ
˜%K˜šΟnœ˜Kšœ˜Kšœ˜—Kšœ
œ
˜K˜Kšž
œœ
œœ
˜#Kšžœœ
œœ
˜K˜Kšœœœ
˜Kšžœœ
œœœ
œœ˜DK˜Kšœœœ	˜Kšœ	œœ	œœ
œ˜;K˜šœœœ˜Kšœœ
˜K˜
Kš	œœ
œ
œœ˜;Kš
œ˜—K˜Kšœœœ
˜"Kšœ
œœœ	œ
œ˜>K˜šœ
œœ˜Kš
œ˜Kš
œ˜Kš
œ˜šœ	œ	˜K˜
Kš
œ7˜7Kšœ˜	——K˜šœœœœ
˜'Kšœœœœ˜ —K˜šœœœœ
˜'Kšœœœœ˜ —K˜šœœœœ
˜$Kšœœœ˜—K˜šœœœœ
˜#Kšœœœœ˜ —K˜šžœœœœ
˜%K™ˆ
Kšœœœ˜—K˜šžœœœœ
˜$K™‰
Kšœœœœ˜ —K˜Kšœœ˜!Kšœœ˜ K˜šžœœ
œ^˜oKšœ_œ˜eKšœ_œ˜fKšœœ/˜FKšœœ/˜FKšœœœœ
œœœœœœ
˜UKš
œ%˜%Kš
œ%˜%Kš
œ4˜4šœ
œ
˜šœœœ˜7Kšžœœœœ˜7Kš
œ)˜)—šœœœ˜8Kš
žœœ
œœ
œ˜>Kš
œ-˜-—šœœœ˜8Kšžœœœ˜ Kšœœ
œ
œœœ˜@Kšœ-œ'œ˜jKš
œΤ˜Τ—šœœœ˜9Kšžœœœ˜ Kšœ-œ'œ˜jKš
œγ˜γ—šœœœ˜8Kšœ
œœœ'˜T—šœœœ˜9Kš	œœœ
œœ˜b—šœœœ˜9Kšœœ
œ
œœœ˜@Kšœ-œ'œ˜iKšœœœΛ˜θ—šœœœ˜:Kšœ-œ'œ˜iKšœœœΜ˜ψ—Kšœœ
˜—Kš
œ4˜4Kšœ˜—K˜š
žœœ"œœœ˜`Kšœœ˜.K˜
Kšœœ˜šœœœ
˜1K˜Kš
œ,˜,šœ
œ
˜Kšœ	œ	˜Kš
œL˜LKšœE˜Hšœ˜Kšœœ˜Kšœ	œœœ
˜1Kš
œI˜IKš
œ	˜	——K˜K˜
Kšœ
˜—Kšœœ
œ
˜Kšœ
œ	œ˜*Kšœ
Οc4œœ	˜UKšœ	œœœ
˜1šœœ
œ˜#Kš
œ-˜-šœœ
˜Kšœœ
˜Kšœœ ˜:Kšœœ
˜—Kšœ
˜—Kšœœ˜,—K˜Kš
œ
œœœ
œ
œ
œ˜9Kšœ	œœœ
œ
œ
œ
œ
œ˜?K˜šž
œœ˜*Kšœœ
œ
˜&šœœ
œ˜#K˜K˜Kšœœ
œ
˜ šœœ˜#Kš	œœ
œ
œœ
˜4Kš	œœ
œ
œœ
˜4Kš
œ=˜=Kšœ	œ
œœ
˜1K˜
—šœ˜Kš	œœ
œ
œœ
˜3Kš	œœ
œ
œœ
˜3Kšœœ˜šœœ
œ&˜7K˜Kšœœ
˜
Kšœ
˜—K˜—Kšœ
˜—Kšœ˜—K˜šžœœœ˜1šœœ
˜Kšœ
œ˜.Kšœœœ˜5Kšœœ˜——K˜šžœœœ˜6Kšœœ˜#šœœ
œ˜!Kš
œ@˜@Kšœ
˜—Kšœ˜—K˜šž
œœ
œœ˜@Kšœœ˜Kš
œœœ
œœ
˜MKšœœ˜Kš
œœœ
œœ
˜GKšœ˜—K˜šžœœa˜oKš
œ[˜[Kšœ˜—K˜Kšœ
œœ˜'Kšœ	œœ
œ˜&Kšœœœ
	œ
œ
œ˜>Kšœœœ
œ˜2Kšœœœ˜Kšœœœ&˜?K˜KšœœœO˜cKšœœœT˜hKšœœœJœ˜mKšœœœOœ˜rKšœœœTœ˜wKšœœœJœœœ˜}KšœœœOœœœ˜‚
KšœœœTœœœ˜‡
Kšœœœ\œ˜~Kšœœœaœ™ƒ
Kšœœœfœ™ˆ
Kšœœœœ&™LKšœœœBœB˜ž
KšœœœOœœœ˜‚
KšœœœOœœ	œ˜„
KšœœœOœœ	œ˜„
K˜šžœœ˜'Kš	œœ
œœ
œ˜(Kšœœ
œœ
˜Kšœœœ˜Kšœœœ˜"Kšœœœ˜"Kšœœœ˜(K˜Kšœœœ˜Kšœœœ˜Kšœœœ˜#Kšœœœ˜#Kšœœœ˜$Kšœœœ˜"Kš	œœ	œ
œœ˜*Kšœœ
˜Kšœœ
˜Kšœœœ7˜RKšœœœ;˜VKšœœœ?˜ZKšœœœ˜)Kšœœœ˜)Kšœœœ˜)Kšž	œœœ˜,Kšžœœ˜+KšœœœC˜\Kšœœ
˜Kšœœœœ˜:Kšœœ
œ
œ+˜AKšœœ
œ	œœ
œœ
˜MKšœœ5˜BKš
œC™CKšœ1˜9Kšœœœœœœœœ˜ZKšœ˜˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœœ˜Kš$œœœœœœœœœœœœœœœœœœ˜―Kšœœ˜—Kšœ@œ*˜nK˜—˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœ
œ˜Kš$œœœœœœœœœœœœœœœœœœ˜―Kšœœ˜—Kšœ5œ˜LK˜—˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœ
œ˜Kš"œœœœœœœœœœœœœœœœœ˜•Kšœœ˜—Kšœ5œ˜LK˜—˜KšœTœ‰
˜α
š
œ	˜	Kšœ
œ˜Kšœ
œœœœœ˜ZKšœ
œœœœœ˜ZKšœœœœœœ˜aKšœœœœœœ˜c—KšœPœ…
˜Ω
K˜—˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœœ˜Kš$œœœœœœœœœœœœœœœœœœ˜―Kšœœ˜—Kšœ?œ*˜mK˜—˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœ
œ˜Kš$œœœœœœœœœœœœœœœœœœ˜―Kšœœ˜—Kšœ3œ˜JK˜—˜š
œ	˜	Kšœ
œ˜Kš
œ˜Kšœ
œ˜Kš"œœœœœœœœœœœœœœœœœ˜•Kšœœ˜—Kšœ3œ˜JK˜—˜KšœPœ…
˜Ω
š
œ	˜	Kšœ
œ˜Kšœ
œœœœœ˜ZKšœ
œœœœœ˜ZKšœœœœœœ˜aKšœœœœœœ˜c—KšœOœ…
˜Ψ
KšœOœ…
˜Ψ
K˜—Kšœv˜}Kšœ˜—K˜Kšœœ˜!Kšœœ˜!Kšœœœ˜%Kšœœœ˜,Kšœœœ˜%Kšœœœ˜(Kšœœœ˜(Kšœœœ˜/Kšžœœ˜*Kšžœœ™#Kšžœœ™#KšœœœB˜ZK˜K˜K˜GK˜Kšœ
˜—…—Dς[‰