;Alto->8086 small-c compiler rev 2.0
C_CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(rpcbonsai.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include <Signal.h>

; extern int Call();

; extern int *mySoc;

; extern StartCall();

; extern int RejectUnbound;

; extern struct PBI *GetPBI();

; extern ReleasePBI();

; extern DISABLE();

; extern ENABLEWithFrame();

; extern SIGNAL();

; extern Call1();

; extern CallersFrame();

; extern MoveBlock();

; extern MyFrame();

; static UnwindPkt(sig, code, seal)
_UnwindPkt:

;   int sig, code;

;   struct Seal1 *seal;
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;
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, CallersFrame(MyFrame()));
MOV BX,1
PUSH BX
MOV BX,OFFSET _UnwindPkt
PUSH BX
CALL _MyFrame
CALL _CallersFrame

;	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 *StartBonsai(interface, seal)
_StartBonsai:

;   struct ImportInstance *interface;

;   struct Seal1 *seal;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   struct PBI *pkt;

;   struct Header *hdr;
ADD SP,0FFFCX

;   pkt = GetUnwindPkt(seal);

;	BX _ _seal
MOV BX,[BP-4]
CALL _GetUnwindPkt

;	_pkt _ BX
MOV [BP-6],BX

;   StartCall(pkt, interface, interface->currentConversation);

;	BX _ _pkt
MOV BX,[BP-6]
PUSH BX

;	BX _ _interface
MOV BX,[BP-2]
MOV CX,[BX+2]
MOV BX,CX

;	CX _ _interface
MOV CX,[BP-2]
CALL _StartCall
POP DX

;   hdr = pkt->pup;

;	BX _ _pkt
MOV BX,[BP-6]
MOV CX,[BX+6]

;	_hdr _ CX
POP DX
PUSH CX

;   return(&hdr->callData.words[0]);

;	BX _ _hdr
POP BX
PUSH BX
ADD BX,028X
MOV SP,BP
POP BP
RET;

;   };

; CallBonsai(seal, arglen)
_CallBonsai:

;   struct Seal1 *seal;

;   int arglen;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   Call(seal->data[0], arglen, maxDataLength);

;	BX _ _seal
MOV BX,[BP-2]
ADD BX,4
MOV CX,[BX]
PUSH CX
MOV BX,076X

;	CX _ _arglen
MOV CX,[BP-4]
CALL _Call
POP DX

;   };
MOV SP,BP
POP BP
RET;

; CleanupCall(seal)
_CleanupCall:

;   struct Seal1 *seal;
PUSH BP
MOV BP,SP
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;

; int BonsaiDispatcher(pkt, newLength, conversation, sSpecsT)
_BonsaiDispatcher:

;   struct PBI *pkt;

;   int newLength;

;   int *conversation;

;   struct SSpecsTable *sSpecsT;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int rout, argLen, *wp;

;   int thisProc;

;   struct Header *hdr;
ADD SP,0FFF6X

;   hdr = pkt->pup;

;	BX _ _pkt
MOV BX,[BP+6]
MOV CX,[BX+6]

;	_hdr _ CX
POP DX
PUSH CX

;   wp = &hdr->callData.words[0];

;	BX _ _hdr
POP BX
PUSH BX
ADD BX,028X

;	_wp _ BX
MOV [BP-10],BX

;   rout = Swab(*wp);

;	DI _ _wp
MOV DI,[BP-10]
MOV BX,[DI]
CALL _Swab

;	_rout _ BX
MOV [BP-6],BX

;   if ((rout < lupineOffset) || (rout > sSpecsT->maxProcs)) SIGNAL(RejectUnbound);

;	BX _ _rout
MOV BX,[BP-6]
CMP BX,4
JL X3

;	DI _ _sSpecsT
MOV DI,[BP-4]
MOV BX,[DI]

;	CX _ _rout
MOV CX,[BP-6]
CMP CX,BX
JLE X2
X3:
MOV AL,1
JR X4
X2:
XOR AL,AL
X4:
OR AL,AL
JZ X1
MOV BX,_RejectUnbound
CALL _SIGNAL
X1:

;   thisProc = sSpecsT->procs[rout];

;	BX _ _sSpecsT
MOV BX,[BP-4]
INC BX
INC BX

;	CX _ _rout
MOV CX,[BP-6]
SAL CX
ADD BX,CX
MOV CX,[BX]

;	_thisProc _ CX
MOV [BP-12],CX

;   if (thisProc == 0) SIGNAL(RejectUnbound);

;	BX _ _thisProc
MOV BX,[BP-12]
OR BX,BX
JNZ X5
MOV BX,_RejectUnbound
CALL _SIGNAL
X5:

;   return (Call1(thisProc, wp));

;	BX _ _wp
MOV BX,[BP-10]

;	CX _ _thisProc
MOV CX,[BP-12]
CALL _Call1
MOV SP,BP
POP BP
RET;

;   };

; int *StringToPkt(pp, s)
_StringToPkt:

;   int *pp;

;   struct ShortSTRING *s;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int len;

;   if (s == 0) *pp++ = swapped1; /* isNil */
PUSH DX

;	BX _ _s
MOV BX,[BP-4]
OR BX,BX
JNZ X6
ADD WORD PTR [BP-2],2

;	BX _ _pp
MOV BX,[BP-2]
MOV WORD PTR [BX-2],0100X

;   else {
JR X7
X6:

;     *pp++ = 0; /* isNil */
ADD WORD PTR [BP-2],2

;	BX _ _pp
MOV BX,[BP-2]
MOV WORD PTR [BX-2],0

;     *pp++ = Swab(s->length);
ADD WORD PTR [BP-2],2

;	BX _ _pp
MOV BX,[BP-2]
PUSH BX

;	DI _ _s
MOV DI,[BP-4]
MOV BX,[DI]
CALL _Swab
MOV CX,BX
POP BX
MOV [BX-2],CX

;     len = (s->length+1) >> 1;  /* text only */

;	DI _ _s
MOV DI,[BP-4]
MOV BX,[DI]
INC BX
SHR BX

;	_len _ BX
POP DX
PUSH BX

;     MoveBlock(pp, &s->text[0], len);

;	BX _ _pp
MOV BX,[BP-2]
PUSH BX

;	BX _ _s
MOV BX,[BP-4]
ADD BX,4
PUSH BX

;	BX _ _len
MOV BX,[BP-6]
POP CX
CALL _MoveBlock
POP DX

;     pp += len;

;	BX _ _len
POP BX
PUSH BX
SAL BX
ADD [BP-2],BX

;     };
X7:

;   return (pp);

;	BX _ _pp
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;

;   };

; struct ShortSTRING

; *AllocStringFromPkt(pp)
_AllocStringFromPkt:

;   int **pp;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   int len, *wp;

;   struct ShortSTRING *s;
ADD SP,0FFFAX

;   wp = *pp;

;	DI _ _pp
MOV DI,[BP-2]
MOV BX,[DI]

;	_wp _ BX
MOV [BP-6],BX

;   if (*wp) {

;	DI _ _wp
MOV DI,[BP-6]
MOV BX,[DI]
OR BX,BX
JZ X8

;     *pp = wp+1;

;	BX _ _wp
MOV BX,[BP-6]
INC BX
INC BX
MOV CX,BX

;	BX _ _pp
MOV BX,[BP-2]
MOV [BX],CX

;     return(0);
XOR BX,BX
MOV SP,BP
POP BP
RET;

;     };
X8:

;   len = (Swab(wp[1])+5)/2;

;	BX _ _wp
MOV BX,[BP-6]
MOV CX,[BX+2]
MOV BX,CX
CALL _Swab
ADD BX,5
SAR BX

;	_len _ BX
MOV [BP-4],BX

;   if (len > 100) CallSwat(ecLarkImpl + 22);

;	BX _ _len
MOV BX,[BP-4]
CMP BX,064X
JLE X9
MOV BX,07016X
CALL _CallSwat
X9:

;   s = (struct ShortSTRING *) GetFixed(len);

;	BX _ _len
MOV BX,[BP-4]
CALL _GetFixed

;	_s _ BX
POP DX
PUSH BX

;   MoveBlock(s, wp, len);

;	BX _ _s
POP BX
PUSH BX
PUSH BX

;	BX _ _len
MOV BX,[BP-4]

;	CX _ _wp
MOV CX,[BP-6]
CALL _MoveBlock
POP DX

;   s->maxLength = Swab(s->maxLength);

;	BX _ _s
POP BX
PUSH BX
PUSH BX

;	BX _ _s
MOV BX,[BP-8]
MOV CX,[BX+2]
MOV BX,CX
CALL _Swab
MOV CX,BX
POP BX
MOV [BX+2],CX

;   s->length = s->maxLength;

;	BX _ _s
POP BX
PUSH BX
MOV CX,[BX+2]

;	BX _ _s
POP BX
PUSH BX
MOV [BX],CX

;   *pp = wp + len;

;	BX _ _len
MOV BX,[BP-4]

;	CX _ _wp
MOV CX,[BP-6]
SAL BX
ADD BX,CX
MOV CX,BX

;	BX _ _pp
MOV BX,[BP-2]
MOV [BX],CX

;   return(s);

;	BX _ _s
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;

;   };

; int *AllocWordsFromPkt(pp, swap)
_AllocWordsFromPkt:

;   int **pp;

;   int swap;  /* boolean */
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int len, *wp;

;   int *wseq;
ADD SP,0FFFAX

;   wp = *pp;

;	DI _ _pp
MOV DI,[BP-2]
MOV BX,[DI]

;	_wp _ BX
MOV [BP-8],BX

;   if (*wp) {

;	DI _ _wp
MOV DI,[BP-8]
MOV BX,[DI]
OR BX,BX
JZ X10

;     *pp = wp+1;

;	BX _ _wp
MOV BX,[BP-8]
INC BX
INC BX
MOV CX,BX

;	BX _ _pp
MOV BX,[BP-2]
MOV [BX],CX

;     return(0);
XOR BX,BX
MOV SP,BP
POP BP
RET;

;     };
X10:

;   len = Swab(wp[1]);

;	BX _ _wp
MOV BX,[BP-8]
MOV CX,[BX+2]
MOV BX,CX
CALL _Swab

;	_len _ BX
MOV [BP-6],BX

;   if (len > 100) CallSwat(ecLarkImpl + 22);

;	BX _ _len
MOV BX,[BP-6]
CMP BX,064X
JLE X11
MOV BX,07016X
CALL _CallSwat
X11:

;   wseq = GetFixed(len+1);

;	BX _ _len
MOV BX,[BP-6]
INC BX
CALL _GetFixed

;	_wseq _ BX
POP DX
PUSH BX

;   *wseq = Swab(wp[3]);

;	BX _ _wp
MOV BX,[BP-8]
MOV CX,[BX+6]
MOV BX,CX
CALL _Swab
MOV CX,BX

;	BX _ _wseq
POP BX
PUSH BX
MOV [BX],CX

;   Marshall(swap, wseq+1, &wp[4], len);

;	BX _ _swap
MOV BX,[BP-4]
PUSH BX

;	BX _ _wseq
MOV BX,[BP-10]
INC BX
INC BX
PUSH BX

;	BX _ _wp
MOV BX,[BP-8]
ADD BX,8
PUSH BX

;	BX _ _len
MOV BX,[BP-6]
POP CX
CALL _Marshall
ADD SP,4

;   *pp = wp + len + 4;

;	BX _ _len
MOV BX,[BP-6]
ADD BX,4

;	CX _ _wp
MOV CX,[BP-8]
SAL BX
ADD BX,CX
MOV CX,BX

;	BX _ _pp
MOV BX,[BP-2]
MOV [BX],CX

;   return(wseq);

;	BX _ _wseq
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;

;   };

; SwabInPlace(addr, words)
_SwabInPlace:

;   int *addr, words;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   Marshall(true, addr, addr, words);
MOV BX,0FFFFX
PUSH BX

;	BX _ _addr
MOV BX,[BP-2]
PUSH BX

;	BX _ _words
MOV BX,[BP-4]

;	CX _ _addr
MOV CX,[BP-2]
CALL _Marshall
ADD SP,4

;   };
MOV SP,BP
POP BP
RET;

; Externals Declared Here
PUBLIC _StartBonsai
PUBLIC _CallBonsai
PUBLIC _CleanupCall
PUBLIC _BonsaiDispatcher
PUBLIC _StringToPkt
PUBLIC _AllocStringFromPkt
PUBLIC _AllocWordsFromPkt
PUBLIC _SwabInPlace

C_CODE ENDS

; Number of Bytes of Code = 02DDX, (733)