;Alto->8086 small-c compiler rev 2.0
C←CODE SEGMENT
$INCLUDE(8086LIB.D)
$INCLUDE(RPCFir.DEC)
ASSUME CS:C←CODE, DS:C←DATA
; #include <Alloc.h>
; extern int Call();
; extern int *mySoc;
; extern struct ZN *myZone;
; extern StartCall();
; extern int CallFailed;
; extern int RejectUnbound;
; extern struct PBI *GetPBI();
; extern ReleasePBI();
; extern int *Allocate();
; extern int *MyFrame();
; extern Free();
; extern int *MyFrame();
; extern int **CallersFrame();
; extern Marshall(/* swapBytes, dest, source, nWords */);
; extern int apply(/* int args[], proc, nargs */ );
; struct Type {
; int esWord; /* = {
; int overhead; /* non-duplicated header, assumed words (to be swapped) */
; int length; /* number of elements, or index thereof */
; };
; struct Sequence {
; int maxLength;
; int data[1];
; };
; struct DSpecs {
; int *proc; /* The remote procedure !!! */
; struct ShortSTRING *argSpecs; /* string specifying parameters */
; struct ShortSTRING *resSpecs; /* one-character string specifying results. */
; };
; struct DSpecsTable {
; int *Free; /*: PROC{dSpecsTable;}; -- releases table */
; int maxProcs;
; struct DSpecs entries[1];
; };
; static struct Type *types[];
; struct Type
; *dBlock(elementSize, overhead, length, atLen, eltWd)
←dBlock:
; int elementSize, overhead, length, atLen, eltWd;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; struct Type *res;
PUSH DX
; res = (struct Type *) Allocate(myZone, lenType);
MOV BX,3
MOV CX,←myZone
CALL ←Allocate
; ←res ← BX
POP DX
PUSH BX
; res->esWord = elementSize; /* element size field is low order */
; BX ← ←res
POP BX
PUSH BX
; CX ← ←elementSize
MOV CX,[BP+8]
MOV [BX],CX
; res->overhead = overhead;
; BX ← ←res
POP BX
PUSH BX
; CX ← ←overhead
MOV CX,[BP+6]
MOV [BX+2],CX
; res->length = length;
; BX ← ←res
POP BX
PUSH BX
; CX ← ←length
MOV CX,[BP+4]
MOV [BX+4],CX
; if (atLen) res->esWord |= atLenField;
; BX ← ←atLen
MOV BX,[BP-2]
OR BX,BX
JZ X1
; BX ← ←res
POP BX
PUSH BX
OR WORD PTR [BX],04000X
X1:
; if (eltWd) res->esWord |= eltsAreWordsField;
; BX ← ←eltWd
MOV BX,[BP-4]
OR BX,BX
JZ X2
; BX ← ←res
POP BX
PUSH BX
OR WORD PTR [BX],08000X
X2:
; return (res);
; BX ← ←res
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;
; };
; static int
; BlockSize(loc, type, lvLen)
←BlockSize:
; int loc[]; struct Type *type; int *lvLen;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; int eltLen, numElts, temp;
; if ((type->esWord&atLenField)==0) numElts = type->length;
ADD SP,0FFFAX
; DI ← ←type
MOV DI,[BP-2]
MOV BX,[DI]
AND BX,04000X
OR BX,BX
JNZ X3
; BX ← ←type
MOV BX,[BP-2]
MOV CX,[BX+4]
; ←numElts ← CX
MOV [BP-8],CX
; else {
JR X4
X3:
; numElts = loc[type->length];
; BX ← ←type
MOV BX,[BP-2]
MOV CX,[BX+4]
; BX ← ←loc
MOV BX,[BP+4]
SAL CX
ADD BX,CX
MOV CX,[BX]
; ←numElts ← CX
MOV [BP-8],CX
; if (lvLen==0) numElts = swab(numElts);
; BX ← ←lvLen
MOV BX,[BP-4]
OR BX,BX
JNZ X5
; BX ← ←numElts
MOV BX,[BP-8]
CALL ←swab
; ←numElts ← BX
MOV [BP-8],BX
X5:
; };
X4:
; if (lvLen) *lvLen=swab(numElts);
; BX ← ←lvLen
MOV BX,[BP-4]
OR BX,BX
JZ X6
; BX ← ←numElts
MOV BX,[BP-8]
CALL ←swab
MOV CX,BX
; BX ← ←lvLen
MOV BX,[BP-4]
MOV [BX],CX
X6:
; eltLen = type->esWord&elementSizeField;
; DI ← ←type
MOV DI,[BP-2]
MOV BX,[DI]
AND BX,07FFX
; ←eltLen ← BX
MOV [BP-6],BX
; if (eltLen >= 16) temp = (eltLen >> 4)*numElts;
; BX ← ←eltLen
MOV BX,[BP-6]
CMP BX,010X
JL X7
MOV CX,4
; BX ← ←eltLen
MOV BX,[BP-6]
SHR BX,CX
MOV AX,BX
; BX ← ←numElts
MOV BX,[BP-8]
IMUL AX,BX
; ←temp ← AX
POP DX
PUSH AX
; else temp = ((numElts-1)/(16/eltLen))+1;
JR X8
X7:
; BX ← ←numElts
MOV BX,[BP-8]
DEC BX
MOV AX,010X
; CX ← ←eltLen
MOV CX,[BP-6]
CWD
IDIV AX,CX
XCHG AX,BX
CWD
IDIV AX,BX
INC AX
; ←temp ← AX
POP DX
PUSH AX
X8:
; Block();
CALL ←Block
; return (type->overhead + temp);
; BX ← ←type
MOV BX,[BP-2]
MOV CX,[BX+2]
; BX ← ←temp
POP BX
PUSH BX
ADD CX,BX
MOV BX,CX
MOV SP,BP
POP BP
RET;
; };
; int
; MarshallFormatted(spec, pkt, pktLength, args)
←MarshallFormatted:
; struct ShortSTRING *spec; struct PBI *pkt; int pktLength; int *args[];
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; int dest[];
; int i; char tChar;
; struct Header *hdr;
; struct ShortSTRING *ss;
; struct Type *type;
; int src[], len, isNil, swapBytes, oLen;
ADD SP,0FFEAX
; hdr = pkt->pup;
; BX ← ←pkt
MOV BX,[BP+4]
MOV CX,[BX+6]
; ←hdr ← CX
MOV [BP-12],CX
; dest = hdr->callData.words;
; BX ← ←hdr
MOV BX,[BP-12]
ADD BX,028X
; ←dest ← BX
MOV [BP-6],BX
; for (i = 0; i<spec->length; ++i) {
MOV WORD PTR [BP-8],0
X11:
; DI ← ←spec
MOV DI,[BP+6]
MOV BX,[DI]
; CX ← ←i
MOV CX,[BP-8]
CMP CX,BX
JGE X10
JR X9
X12:
INC WORD PTR [BP-8]
JR X11
X9:
; Block();
CALL ←Block
; swapBytes=false; oLen=0;
MOV WORD PTR [BP-24],0
MOV WORD PTR [BP-26],0
; src = args[i];
; BX ← ←i
MOV BX,[BP-8]
; CX ← ←args
MOV CX,[BP-4]
SAL BX
ADD BX,CX
MOV CX,[BX]
; ←src ← CX
MOV [BP-18],CX
; isNil = (src)? 0: swapped1;
; BX ← ←src
MOV BX,[BP-18]
OR BX,BX
JZ X13
XOR BX,BX
JR X14
X13:
MOV BX,0100X
X14:
; ←isNil ← BX
MOV [BP-22],BX
; dest[pktLength++] = isNil; /* isNil spec */
INC WORD PTR [BP-2]
; BX ← ←pktLength
MOV BX,[BP-2]
DEC BX
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
; CX ← ←isNil
MOV CX,[BP-22]
MOV [BX],CX
; switch (tChar=spec->text[i]) {
; BX ← ←spec
MOV BX,[BP+6]
ADD BX,4
; CX ← ←i
MOV CX,[BP-8]
ADD BX,CX
MOV AL,[BX]
; ←tChar ← AL
MOV [BP-10],AL
JR X15
; case 'W': {
X17:
; dest[pktLength-1] = swab(src);
; BX ← ←pktLength
MOV BX,[BP-2]
DEC BX
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←src
MOV BX,[BP-18]
CALL ←swab
MOV CX,BX
POP BX
MOV [BX],CX
; continue;
JR X12
; };
; case 'B': {
X18:
; dest[pktLength-1] = (int) src;
; BX ← ←pktLength
MOV BX,[BP-2]
JR $+5
X10:
JMP X19
DEC BX
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
; CX ← ←src
MOV CX,[BP-18]
MOV [BX],CX
; continue;
JMP X12
; };
; case 'D': {
X20:
; --pktLength; /* no "isNil" word */
DEC WORD PTR [BP-2]
; len=2;
MOV WORD PTR [BP-20],2
; swapBytes=true;
MOV WORD PTR [BP-24],0FFFFX
; break;
JR X16
; };
; case 'S': {
X21:
; ss=(struct ShortSTRING *) src;
; BX ← ←src
MOV BX,[BP-18]
; ←ss ← BX
MOV [BP-14],BX
; ++src;
ADD WORD PTR [BP-18],2
; len=(ss->length+3)/2;
; DI ← ←ss
MOV DI,[BP-14]
MOV BX,[DI]
ADD BX,3
SAR BX
; ←len ← BX
MOV [BP-20],BX
; oLen=1;
MOV WORD PTR [BP-26],1
; break;
JR X16
; };
; default: {
X22:
; if (isNil) continue;
; BX ← ←isNil
MOV BX,[BP-22]
OR BX,BX
JZ X23
JMP X12
X23:
; type = types[tChar-'A'];
; AL ← ←tChar
MOV AL,[BP-10]
ADD AL,0BFX
XOR AH,AH
MOV BX,←types
SAL AX
JR $+5
X15:
JMP X24
ADD BX,AX
MOV CX,[BX]
; ←type ← CX
MOV [BP-16],CX
; if (type==0) SIGNAL(CallFailed, badArgs);
; BX ← ←type
MOV BX,[BP-16]
OR BX,BX
JNZ X25
MOV BX,011X
MOV CX,←CallFailed
CALL ←SIGNAL
X25:
; len = BlockSize(src, type, &dest[pktLength++]);
; BX ← ←src
MOV BX,[BP-18]
PUSH BX
INC WORD PTR [BP-2]
; BX ← ←pktLength
MOV BX,[BP-2]
DEC BX
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
; CX ← ←type
MOV CX,[BP-16]
CALL ←BlockSize
POP DX
; ←len ← BX
MOV [BP-20],BX
; oLen = type->overhead;
; BX ← ←type
MOV BX,[BP-16]
MOV CX,[BX+2]
; ←oLen ← CX
POP DX
PUSH CX
; swapBytes = type->esWord&eltsAreWordsField;
; DI ← ←type
JR $+5
X16:
JMP X26
MOV DI,[BP-16]
MOV BX,[DI]
AND BX,08000X
; ←swapBytes ← BX
MOV [BP-24],BX
; if ((type->esWord&atLenField)!=0) dest[pktLength++] = 0;
; DI ← ←type
MOV DI,[BP-16]
MOV BX,[DI]
AND BX,04000X
OR BX,BX
JZ X27
INC WORD PTR [BP-2]
; BX ← ←pktLength
MOV BX,[BP-2]
DEC BX
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
MOV WORD PTR [BX],0
; else pktLength -= 1;
JR X28
X27:
DEC WORD PTR [BP-2]
X28:
; };
; };
JMP X26
X24:
CMP AL,057X
JMPZ X17
CMP AL,042X
JMPZ X18
CMP AL,044X
JMPZ X20
CMP AL,053X
JMPZ X21
JMP X22
X26:
; if (isNil) continue;
; BX ← ←isNil
MOV BX,[BP-22]
OR BX,BX
JZ X29
JMP X12
X29:
; if (oLen) Marshall(true, &dest[pktLength], src, oLen);
; BX ← ←oLen
POP BX
PUSH BX
OR BX,BX
JZ X30
MOV BX,0FFFFX
PUSH BX
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←oLen
MOV BX,[BP-26]
; CX ← ←src
MOV CX,[BP-18]
CALL ←Marshall
ADD SP,4
X30:
; pktLength += oLen;
; BX ← ←oLen
POP BX
PUSH BX
ADD [BP-2],BX
; len-=oLen;
; BX ← ←oLen
POP BX
PUSH BX
SUB [BP-20],BX
; if (len) Marshall(swapBytes, &dest[pktLength], &src[oLen], len);
; BX ← ←len
MOV BX,[BP-20]
OR BX,BX
JZ X31
; BX ← ←swapBytes
MOV BX,[BP-24]
PUSH BX
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←dest
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←oLen
MOV BX,[BP-26]
; CX ← ←src
MOV CX,[BP-18]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←len
MOV BX,[BP-20]
POP CX
CALL ←Marshall
ADD SP,4
X31:
; pktLength += len;
; BX ← ←len
MOV BX,[BP-20]
ADD [BP-2],BX
; };
JMP X12
X19:
; if (pktLength > maxDataLength) SIGNAL(CallFailed, badArgs);
; BX ← ←pktLength
MOV BX,[BP-2]
CMP BX,076X
JLE X32
MOV BX,011X
MOV CX,←CallFailed
CALL ←SIGNAL
X32:
; return pktLength;
; BX ← ←pktLength
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
; };
; int
; UnmarshallFormatted(spec, pkt, pktLength, vbls)
←UnmarshallFormatted:
; struct ShortSTRING *spec;
; struct PBI *pkt;
; int pktLength;
; int vbls[];
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; int src[];
; int *dests, dest[], len, i;
; char tChar;
; struct Header *hdr;
; struct ShortSTRING *ss;
; struct Type *type;
; int isNil, val, oLen, swapBytes;
ADD SP,0FFE6X
; hdr=pkt->pup;
; BX ← ←pkt
MOV BX,[BP+4]
MOV CX,[BX+6]
; ←hdr ← CX
MOV [BP-18],CX
; src = hdr->callData.words;
; BX ← ←hdr
MOV BX,[BP-18]
ADD BX,028X
; ←src ← BX
MOV [BP-6],BX
; for (i = 0; i<spec->length; ++i) {
MOV WORD PTR [BP-14],0
X35:
; DI ← ←spec
MOV DI,[BP+6]
MOV BX,[DI]
; CX ← ←i
MOV CX,[BP-14]
CMP CX,BX
JGE X34
JR X33
X36:
INC WORD PTR [BP-14]
JR X35
X33:
; Block();
CALL ←Block
; swapBytes = oLen = 0;
MOV WORD PTR [BP-28],0
MOV WORD PTR [BP-30],0
; isNil = src[pktLength++];
INC WORD PTR [BP-2]
; BX ← ←pktLength
MOV BX,[BP-2]
DEC BX
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
MOV CX,[BX]
; ←isNil ← CX
MOV [BP-24],CX
; dests=&vbls[i]; if (isNil) *dests=0;
; BX ← ←i
MOV BX,[BP-14]
; CX ← ←vbls
MOV CX,[BP-4]
SAL BX
ADD BX,CX
; ←dests ← BX
MOV [BP-8],BX
; BX ← ←isNil
MOV BX,[BP-24]
OR BX,BX
JZ X37
; BX ← ←dests
MOV BX,[BP-8]
MOV WORD PTR [BX],0
X37:
; switch (tChar=spec->text[i]) {
; BX ← ←spec
MOV BX,[BP+6]
ADD BX,4
; CX ← ←i
MOV CX,[BP-14]
ADD BX,CX
MOV AL,[BX]
; ←tChar ← AL
MOV [BP-16],AL
JR X38
; case 'W': {
X40:
; *dests = swab(isNil); /* no nil test, really */
; BX ← ←isNil
MOV BX,[BP-24]
CALL ←swab
MOV CX,BX
; BX ← ←dests
MOV BX,[BP-8]
MOV [BX],CX
; continue;
JR X36
; };
; case 'B': {
X41:
; *dests = isNil;
; BX ← ←dests
MOV BX,[BP-8]
; CX ← ←isNil
MOV CX,[BP-24]
MOV [BX],CX
; continue;
JR X36
; };
; case 'D': {
X42:
; --pktLength; /* no "isNil" */
DEC WORD PTR [BP-2]
; len=2;
MOV WORD PTR [BP-12],2
; swapBytes=true;
JR $+5
X34:
JMP X43
MOV WORD PTR [BP-30],0FFFFX
; break;
JR X39
; };
; case 'S': {
X44:
; if (isNil) continue;
; BX ← ←isNil
MOV BX,[BP-24]
OR BX,BX
JZ X45
JMP X36
X45:
; ss = (struct ShortSTRING *) &src[pktLength];
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
; ←ss ← BX
MOV [BP-20],BX
; len = (swab(ss->length)+5)/2;
; DI ← ←ss
MOV DI,[BP-20]
MOV BX,[DI]
CALL ←swab
ADD BX,5
SAR BX
; ←len ← BX
MOV [BP-12],BX
; --pktLength;
DEC WORD PTR [BP-2]
; src[pktLength]=src[pktLength+1];
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
; CX ← ←pktLength
MOV CX,[BP-2]
INC CX
; AX ← ←src
MOV AX,[BP-6]
SAL CX
ADD CX,AX
MOV DI,CX
MOV CX,[DI]
MOV [BX],CX
; oLen=2;
JR $+5
X38:
JMP X46
MOV WORD PTR [BP-28],2
; break;
JR X39
; };
; default: {
X47:
; if (isNil) continue;
; BX ← ←isNil
MOV BX,[BP-24]
OR BX,BX
JZ X48
JMP X36
X48:
; type = types[tChar-'A'];
; AL ← ←tChar
MOV AL,[BP-16]
ADD AL,0BFX
XOR AH,AH
MOV BX,←types
SAL AX
ADD BX,AX
MOV CX,[BX]
; ←type ← CX
MOV [BP-22],CX
; if (type==0) SIGNAL(CallFailed, badArgs);
; BX ← ←type
MOV BX,[BP-22]
OR BX,BX
JR $+5
X39:
JMP X50
JNZ X49
MOV BX,011X
MOV CX,←CallFailed
CALL ←SIGNAL
X49:
; if ((type->esWord&atLenField)!=0) pktLength+=2;
; DI ← ←type
MOV DI,[BP-22]
MOV BX,[DI]
AND BX,04000X
OR BX,BX
JZ X51
ADD WORD PTR [BP-2],2
X51:
; len=BlockSize(&src[pktLength], type, 0);
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
XOR BX,BX
; CX ← ←type
MOV CX,[BP-22]
CALL ←BlockSize
POP DX
; ←len ← BX
MOV [BP-12],BX
; oLen=type->overhead;
; BX ← ←type
MOV BX,[BP-22]
MOV CX,[BX+2]
; ←oLen ← CX
MOV [BP-28],CX
; swapBytes = type->esWord&eltsAreWordsField;
; DI ← ←type
MOV DI,[BP-22]
MOV BX,[DI]
AND BX,08000X
; ←swapBytes ← BX
POP DX
PUSH BX
; };
; };
JMP X50
X46:
CMP AL,057X
JMPZ X40
CMP AL,042X
JMPZ X41
CMP AL,044X
JMPZ X42
CMP AL,053X
JMPZ X44
JMP X47
X50:
; *dests= (int) (dest=Allocate(myZone, len));
; BX ← ←len
MOV BX,[BP-12]
MOV CX,←myZone
CALL ←Allocate
; ←dest ← BX
MOV [BP-10],BX
MOV CX,BX
; BX ← ←dests
MOV BX,[BP-8]
MOV [BX],CX
; if (oLen) Marshall(true, dest, &src[pktLength], oLen);
; BX ← ←oLen
MOV BX,[BP-28]
OR BX,BX
JZ X52
MOV BX,0FFFFX
PUSH BX
; BX ← ←dest
MOV BX,[BP-10]
PUSH BX
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←oLen
MOV BX,[BP-28]
POP CX
CALL ←Marshall
ADD SP,4
X52:
; if (len -= oLen) Marshall(swapBytes, &dest[oLen], &src[pktLength+=oLen], len);
; BX ← ←oLen
MOV BX,[BP-28]
SUB [BP-12],BX
; BX ← ←len
MOV BX,[BP-12]
OR BX,BX
JZ X53
; BX ← ←swapBytes
POP BX
PUSH BX
PUSH BX
; BX ← ←oLen
MOV BX,[BP-28]
; CX ← ←dest
MOV CX,[BP-10]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←oLen
MOV BX,[BP-28]
ADD [BP-2],BX
; BX ← ←pktLength
MOV BX,[BP-2]
; CX ← ←src
MOV CX,[BP-6]
SAL BX
ADD BX,CX
PUSH BX
; BX ← ←len
MOV BX,[BP-12]
POP CX
CALL ←Marshall
ADD SP,4
X53:
; pktLength+=len;
; BX ← ←len
MOV BX,[BP-12]
ADD [BP-2],BX
; };
JMP X36
X43:
; if (pktLength > (swab(hdr->length)>>1)-headerSize-1) SIGNAL(CallFailed, badArgs);
; DI ← ←hdr
MOV DI,[BP-18]
MOV BX,[DI]
CALL ←swab
SHR BX
ADD BX,0FFEDX
; CX ← ←pktLength
MOV CX,[BP-2]
CMP CX,BX
JLE X54
MOV BX,011X
MOV CX,←CallFailed
CALL ←SIGNAL
X54:
; return pktLength;
; BX ← ←pktLength
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
; };
; static UnwindPkt(sig, code, seal)
←UnwindPkt:
; int sig, code;
; struct Seal1 *seal;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; ReleasePBI(seal->data[0]);
; BX ← ←seal
POP BX
PUSH BX
ADD BX,4
MOV CX,[BX]
MOV BX,CX
CALL ←ReleasePBI
; DISABLE(seal);
; BX ← ←seal
POP BX
PUSH BX
CALL ←DISABLE
; };
MOV SP,BP
POP BP
RET;
; static struct PBI
; *GetUnwindPkt(seal)
←GetUnwindPkt:
; struct Seal1 *seal;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH BX
; {
; struct PBI *pkt;
PUSH DX
; pkt = GetPBI(mySoc);
MOV BX,←mySoc
CALL ←GetPBI
; ←pkt ← BX
POP DX
PUSH BX
; ENABLEWithFrame(UNWIND, &UnwindPkt, seal, MyFrame());
MOV BX,1
PUSH BX
MOV BX,OFFSET ←UnwindPkt
PUSH BX
CALL ←MyFrame
; CX ← ←seal
MOV CX,[BP-2]
CALL ←ENABLEWithFrame
ADD SP,4
; seal->data[0] = (int) pkt;
; BX ← ←seal
MOV BX,[BP-2]
ADD BX,4
; CX ← ←pkt
POP CX
PUSH CX
MOV [BX],CX
; return (pkt);
; BX ← ←pkt
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;
; };
; int
; CallFormatted(interface, proc, argSpec, retSpec, args)
←CallFormatted:
; struct ImportInstance *interface;
; int *proc;
; struct ShortSTRING *argSpec, *retSpec;
; int *args;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; int pktLength;
; int defArgs[10];
; int callResults[];
; struct PBI *pkt; struct Header *hdr;
; struct Seal1 seal;
; int na;
ADD SP,0FFDCX
; pkt = GetUnwindPkt(&seal);
;&←seal
LEA BX,[BP-38]
CALL ←GetUnwindPkt
; ←pkt ← BX
MOV [BP-30],BX
; na = argSpec->length;
; DI ← ←argSpec
MOV DI,[BP+4]
MOV BX,[DI]
; ←na ← BX
POP DX
PUSH BX
; if (args==0) args = defArgs;
; BX ← ←args
MOV BX,[BP-4]
OR BX,BX
JNZ X55
;&←defArgs
LEA BX,[BP-26]
; ←args ← BX
MOV [BP-4],BX
X55:
; StartCall(pkt, interface, interface->currentConversation);
; BX ← ←pkt
MOV BX,[BP-30]
PUSH BX
; BX ← ←interface
MOV BX,[BP+8]
MOV CX,[BX+2]
MOV BX,CX
; CX ← ←interface
MOV CX,[BP+8]
CALL ←StartCall
POP DX
; hdr = pkt->pup;
; BX ← ←pkt
MOV BX,[BP-30]
MOV CX,[BX+6]
; ←hdr ← CX
MOV [BP-32],CX
; hdr->callData.words[0] = swab(proc);
; BX ← ←hdr
MOV BX,[BP-32]
ADD BX,028X
PUSH BX
; BX ← ←proc
MOV BX,[BP+6]
CALL ←swab
MOV CX,BX
POP BX
MOV [BX],CX
; pktLength = MarshallFormatted(argSpec, pkt, 1, args);
; BX ← ←argSpec
MOV BX,[BP+4]
PUSH BX
; BX ← ←pkt
MOV BX,[BP-30]
PUSH BX
; BX ← ←args
MOV BX,[BP-4]
MOV CX,1
CALL ←MarshallFormatted
ADD SP,4
; ←pktLength ← BX
MOV [BP-6],BX
; Call(pkt, pktLength, maxDataLength);
; BX ← ←pkt
MOV BX,[BP-30]
PUSH BX
MOV BX,076X
; CX ← ←pktLength
MOV CX,[BP-6]
CALL ←Call
POP DX
; callResults = &args[na];
; BX ← ←na
POP BX
PUSH BX
; CX ← ←args
MOV CX,[BP-4]
SAL BX
ADD BX,CX
; ←callResults ← BX
MOV [BP-28],BX
; UnmarshallFormatted(retSpec, pkt, 0, callResults);
; BX ← ←retSpec
MOV BX,[BP-2]
PUSH BX
; BX ← ←pkt
MOV BX,[BP-30]
PUSH BX
; BX ← ←callResults
MOV BX,[BP-28]
XOR CX,CX
CALL ←UnmarshallFormatted
ADD SP,4
; UnwindPkt(0,0,&seal);
XOR BX,BX
PUSH BX
;&←seal
LEA BX,[BP-38]
XOR CX,CX
CALL ←UnwindPkt
POP DX
; return callResults[0];
; DI ← ←callResults
MOV DI,[BP-28]
MOV BX,[DI]
MOV SP,BP
POP BP
RET;
; };
; FreeSpecs(dSpecsT)
←FreeSpecs:
; struct DSpecsTable *dSpecsT;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH BX
; {
; Free(myZone, dSpecsT);
; BX ← ←dSpecsT
POP BX
PUSH BX
MOV CX,←myZone
CALL ←Free
; };
MOV SP,BP
POP BP
RET;
; struct DSpecsTable
; *StartDispatcherSpecs(maxProcs)
←StartDispatcherSpecs:
; int maxProcs;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH BX
; {
; struct DSpecsTable *res;
; if (types==0) AddType('Z', 0); /* force type table initialization */
PUSH DX
MOV BX,←types
OR BX,BX
JNZ X56
XOR BX,BX
MOV CX,05AX
CALL ←AddType
X56:
; res = (struct DSpecsTable *) Allocate(myZone, lenDSpecsTable + (maxProcs * lenDSpecs));
; BX ← ←maxProcs
MOV BX,[BP-2]
MOV DX,BX
SAL BX
ADD BX,DX
INC BX
INC BX
MOV CX,←myZone
CALL ←Allocate
; ←res ← BX
POP DX
PUSH BX
; res->Free = &FreeSpecs;
; BX ← ←res
POP BX
PUSH BX
MOV CX,OFFSET ←FreeSpecs
MOV [BX],CX
; res->maxProcs = maxProcs;
; BX ← ←res
POP BX
PUSH BX
; CX ← ←maxProcs
MOV CX,[BP-2]
MOV [BX+2],CX
; return res;
; BX ← ←res
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;
; };
; AddToDispatcherSpecs(dSpecsT, procIndex, proc, argSpec, retSpec)
←AddToDispatcherSpecs:
; struct DSpecsTable *dSpecsT;
; int procIndex, *proc;
; struct ShortSTRING *argSpec, *retSpec;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; struct DSpecs *dSpecs;
PUSH DX
; procIndex -= lupineOffset;
SUB WORD PTR [BP+6],4
; if (procIndex >= dSpecsT->maxProcs) SIGNAL(ERROR);
; BX ← ←dSpecsT
MOV BX,[BP+8]
MOV CX,[BX+2]
; BX ← ←procIndex
MOV BX,[BP+6]
CMP BX,CX
JL X57
MOV BX,2
CALL ←SIGNAL
X57:
; dSpecs = &dSpecsT->entries[procIndex];
; BX ← ←dSpecsT
MOV BX,[BP+8]
ADD BX,4
; CX ← ←procIndex
MOV CX,[BP+6]
MOV AX,6
IMUL AX,CX
ADD BX,AX
; ←dSpecs ← BX
POP DX
PUSH BX
; dSpecs->proc = proc;
; BX ← ←dSpecs
POP BX
PUSH BX
; CX ← ←proc
MOV CX,[BP+4]
MOV [BX],CX
; dSpecs->argSpecs = argSpec;
; BX ← ←dSpecs
POP BX
PUSH BX
; CX ← ←argSpec
MOV CX,[BP-2]
MOV [BX+2],CX
; dSpecs->resSpecs = retSpec;
; BX ← ←dSpecs
POP BX
PUSH BX
; CX ← ←retSpec
MOV CX,[BP-4]
MOV [BX+4],CX
; Block( );
CALL ←Block
; };
MOV SP,BP
POP BP
RET;
; AddType(letter, type)
←AddType:
; char letter;
; struct Type *type;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; if (type==0) {
; BX ← ←type
POP BX
PUSH BX
OR BX,BX
JNZ X58
; types = (struct Type **) Allocate(myZone, 26);
MOV BX,01AX
MOV CX,←myZone
CALL ←Allocate
MOV ←types,BX
; AddType('Q', dBlock(16, 1, 0, true, true)); /* Word Sequence */
MOV BX,010X
PUSH BX
MOV BX,1
PUSH BX
XOR BX,BX
PUSH BX
MOV BX,0FFFFX
MOV CX,0FFFFX
CALL ←dBlock
ADD SP,6
MOV CX,051X
CALL ←AddType
; AddType('C', dBlock(8, 1, 0, true, false)); /* Byte Sequence */
MOV BX,8
PUSH BX
MOV BX,1
PUSH BX
XOR BX,BX
PUSH BX
XOR BX,BX
MOV CX,0FFFFX
CALL ←dBlock
ADD SP,6
MOV CX,043X
CALL ←AddType
; };
X58:
; types[letter-'A'] = type;
; AL ← ←letter
MOV AL,[BP-2]
ADD AL,0BFX
XOR AH,AH
MOV BX,←types
SAL AX
ADD BX,AX
; CX ← ←type
POP CX
PUSH CX
MOV [BX],CX
; };
MOV SP,BP
POP BP
RET;
; int
; StdDispatcher(pkt, newLength, conversation, dSpecsT)
←StdDispatcher:
; struct PBI *pkt;
; int newLength;
; int *conversation;
; struct DSpecsTable *dSpecsT;
CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX
; {
; int args[10];
; int rout, argLen;
; struct DSpecs *dSpecs;
; struct ShortSTRING *argSpecs;
; struct Header *hdr;
ADD SP,0FFE2X
; hdr = pkt->pup;
; BX ← ←pkt
MOV BX,[BP+6]
MOV CX,[BX+6]
; ←hdr ← CX
POP DX
PUSH CX
; rout = swab(hdr->callData.words[0]) - lupineOffset;
; BX ← ←hdr
POP BX
PUSH BX
ADD BX,028X
MOV CX,[BX]
MOV BX,CX
CALL ←swab
ADD BX,0FFFCX
; ←rout ← BX
MOV [BP-26],BX
; if (rout >= dSpecsT->maxProcs) SIGNAL(RejectUnbound);
; BX ← ←dSpecsT
MOV BX,[BP-4]
MOV CX,[BX+2]
; BX ← ←rout
MOV BX,[BP-26]
CMP BX,CX
JL X59
MOV BX,←RejectUnbound
CALL ←SIGNAL
X59:
; dSpecs = &dSpecsT->entries[rout];
; BX ← ←dSpecsT
MOV BX,[BP-4]
ADD BX,4
; CX ← ←rout
MOV CX,[BP-26]
MOV AX,6
IMUL AX,CX
ADD BX,AX
; ←dSpecs ← BX
MOV [BP-30],BX
; argSpecs = dSpecs->argSpecs;
; BX ← ←dSpecs
MOV BX,[BP-30]
MOV CX,[BX+2]
; ←argSpecs ← CX
MOV [BP-32],CX
; argLen = argSpecs->length;
; DI ← ←argSpecs
MOV DI,[BP-32]
MOV BX,[DI]
; ←argLen ← BX
MOV [BP-28],BX
; if (argLen>10) SIGNAL(CallFailed, badArgs);
; BX ← ←argLen
MOV BX,[BP-28]
CMP BX,0AX
JLE X60
MOV BX,011X
MOV CX,←CallFailed
CALL ←SIGNAL
X60:
; if (dSpecs->proc == 0) SIGNAL(RejectUnbound);
; DI ← ←dSpecs
MOV DI,[BP-30]
MOV BX,[DI]
OR BX,BX
JNZ X61
MOV BX,←RejectUnbound
CALL ←SIGNAL
X61:
; UnmarshallFormatted(argSpecs, pkt, 1, args);
; BX ← ←argSpecs
MOV BX,[BP-32]
PUSH BX
; BX ← ←pkt
MOV BX,[BP+6]
PUSH BX
;&←args
LEA BX,[BP-24]
MOV CX,1
CALL ←UnmarshallFormatted
ADD SP,4
; args[0] = apply(args, dSpecs->proc, argLen);
;&←args
LEA BX,[BP-24]
PUSH BX
; DI ← ←dSpecs
MOV DI,[BP-30]
MOV BX,[DI]
PUSH BX
; BX ← ←argLen
MOV BX,[BP-28]
POP CX
CALL ←apply
POP DX
; ←args ← BX
MOV [BP-24],BX
; return (MarshallFormatted(dSpecs->resSpecs, pkt, 0, args));
; BX ← ←dSpecs
MOV BX,[BP-30]
MOV CX,[BX+4]
PUSH CX
; BX ← ←pkt
MOV BX,[BP+6]
PUSH BX
;&←args
LEA BX,[BP-24]
XOR CX,CX
CALL ←MarshallFormatted
ADD SP,4
MOV SP,BP
POP BP
RET;
; };
; int *GetDispatcherArgs()
←GetDispatcherArgs:
CALL StkChk
PUSH BP
MOV BP,SP
; {
; int *f[];
PUSH DX
; f = CallersFrame /* to apply frame */
; (CallersFrame /* to interface procedure */
; (MyFrame /* to GetDispatchersArgs frame */ ()));
CALL ←MyFrame
CALL ←CallersFrame
CALL ←CallersFrame
; ←f ← BX
POP DX
PUSH BX
; return (f[2]);
; BX ← ←f
POP BX
PUSH BX
MOV CX,[BX+4]
MOV BX,CX
MOV SP,BP
POP BP
RET;
; };
; int *GetServerConversation()
←GetServerConversation:
CALL StkChk
PUSH BP
MOV BP,SP
; {
; int *f[];
PUSH DX
; f = CallersFrame /* to StdDispatcher's frame */
; (CallersFrame /* to apply frame */
; (CallersFrame /* to interface procedure */
; (MyFrame /* to GetDispatchersArgs frame */ ())));
CALL ←MyFrame
CALL ←CallersFrame
CALL ←CallersFrame
CALL ←CallersFrame
; ←f ← BX
POP DX
PUSH BX
; return (f[-1]);
; BX ← ←f
POP BX
PUSH BX
MOV CX,[BX-2]
MOV BX,CX
MOV SP,BP
POP BP
RET;
; };
; Externals Declared Here
PUBLIC ←dBlock
PUBLIC ←MarshallFormatted
PUBLIC ←UnmarshallFormatted
PUBLIC ←CallFormatted
PUBLIC ←FreeSpecs
PUBLIC ←StartDispatcherSpecs
PUBLIC ←AddType
PUBLIC ←AddToDispatcherSpecs
PUBLIC ←StdDispatcher
PUBLIC ←GetDispatcherArgs
PUBLIC ←GetServerConversation
C←CODE ENDS
; Number of Bytes of Code = 081EX, (2078)