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

$INCLUDE(8086LIB.D)

$INCLUDE(RPCUtilsImpl.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include <Env.h>

; extern int NewPSB();

; extern int Min();

; extern int lc();

; extern struct RPCCtx *CurrentContext();

; extern int *Enqueue();

; extern struct RPCCtx *InitNContext();

; extern int *GetFixed();

; extern int CallSwat();

; extern int MoveBlock();

; extern int Zero();

; extern int DoubleDiff();

; struct HostNet {

;   char net;

;   char host;

;   };

; union Machine {

;   int w;

;   struct HostNet b;

;   };

; struct Calendar {

;   int time[2];

;   int zoneInfo;

;   int dstStartDay;

;   int dstEndDay;

;   int base[2];	/* last ms timer, for updating time */

;   };

; static struct Calendar calendar;

; int /*bool allFit*/

; AppendString(tO, fRom)
_AppendString:

;   struct ShortSTRING *tO, *fRom;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   { /* RETURNS[allFit: BOOLEAN]*/

;   int i, toLen, totLen, fromLen;
ADD SP,0FFF8X

;   toLen = tO->length;

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

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

;   totLen = Min(tO->maxLength, toLen+fRom->length);

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

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

;	AX _ _toLen
MOV AX,[BP-8]
ADD AX,BX
MOV BX,AX
CALL _Min

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

;   fromLen = totLen-toLen;

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

;	CX _ _totLen
MOV CX,[BP-10]
SUB CX,BX

;	_fromLen _ CX
POP DX
PUSH CX

;   for (i=0; i<fromLen; ++i) tO->text[i+toLen] = fRom->text[i];
MOV WORD PTR [BP-6],0
X3:

;	BX _ _fromLen
POP BX
PUSH BX

;	CX _ _i
MOV CX,[BP-6]
CMP CX,BX
JGE X2
JR X1
X4:
INC WORD PTR [BP-6]
JR X3
X1:

;	BX _ _tO
MOV BX,[BP-2]
ADD BX,4

;	CX _ _toLen
MOV CX,[BP-8]

;	AX _ _i
MOV AX,[BP-6]
ADD AX,CX
ADD BX,AX

;	CX _ _fRom
MOV CX,[BP-4]
ADD CX,4

;	AX _ _i
MOV AX,[BP-6]
ADD AX,CX
MOV DI,AX
MOV AL,[DI]
MOV [BX],AL
JR X4
X2:

;   tO->length = totLen;

;	BX _ _tO
MOV BX,[BP-2]

;	CX _ _totLen
MOV CX,[BP-10]
MOV [BX],CX

;   return(fromLen == fRom->length);

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

;	CX _ _fromLen
POP CX
PUSH CX
CMP CX,BX
JNZ X5
MOV BX,1
JR X6
X5:
XOR BX,BX
X6:
MOV SP,BP
POP BP
RET;

;   };

; int /*bool*/

; EquivalentStrings(a,b)
_EquivalentStrings:

;   struct ShortSTRING *a, *b;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int i;

;   if (a->length != b->length) return(false);
PUSH DX

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

;	DI _ _b
MOV DI,[BP-4]
MOV CX,[DI]
CMP BX,CX
JZ X7
XOR BX,BX
MOV SP,BP
POP BP
RET;
X7:

;   for (i=0; i<a->length; ++i)
MOV WORD PTR [BP-6],0
X10:

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

;	CX _ _i
POP CX
PUSH CX
CMP CX,BX
JGE X9
JR X8
X11:
INC WORD PTR [BP-6]
JR X10
X8:

;     if (lc(a->text[i]) != lc(b->text[i])) return(false);

;	BX _ _a
MOV BX,[BP-2]
ADD BX,4

;	CX _ _i
POP CX
PUSH CX
ADD BX,CX
MOV AL,[BX]
CBW
MOV BX,AX
CALL _lc
PUSH BX

;	BX _ _b
MOV BX,[BP-4]
ADD BX,4

;	CX _ _i
MOV CX,[BP-6]
ADD BX,CX
MOV AL,[BX]
CBW
MOV BX,AX
CALL _lc
POP CX
CMP CX,BX
JZ X12
XOR BX,BX
MOV SP,BP
POP BP
RET;
X12:
JR X11
X9:

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

;   };

; struct ShortSTRING

; *CStringToString(b)
_CStringToString:

;   char b[];
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   int len, i;

;   struct ShortSTRING *s;
ADD SP,0FFFAX

;   len = strlen(b);

;	BX _ _b
MOV BX,[BP-2]
CALL _strlen

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

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

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

;	_s _ BX
POP DX
PUSH BX

;   s->length = s->maxLength = len;

;	BX _ _s
POP BX
PUSH BX

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

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

;   for (i = 0; i<len; ++i) s->text[i] = b[i];
MOV WORD PTR [BP-6],0
X15:

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

;	CX _ _i
MOV CX,[BP-6]
CMP CX,BX
JGE X14
JR X13
X16:
INC WORD PTR [BP-6]
JR X15
X13:

;	BX _ _s
POP BX
PUSH BX
ADD BX,4

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

;	CX _ _i
MOV CX,[BP-6]

;	AX _ _b
MOV AX,[BP-2]
ADD CX,AX
MOV DI,CX
MOV AL,[DI]
MOV [BX],AL
JR X16
X14:

;   return(s);

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

;   };

; static int strlen(b)
_strlen:

;   char b[];
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   int i;

;   for (i = 0; i<100; ++i) if (b[i] == 0) return (i);
PUSH DX
MOV WORD PTR [BP-4],0
X19:

;	BX _ _i
POP BX
PUSH BX
CMP BX,064X
JGE X18
JR X17
X20:
INC WORD PTR [BP-4]
JR X19
X17:

;	BX _ _i
POP BX
PUSH BX

;	CX _ _b
MOV CX,[BP-2]
ADD BX,CX
MOV AL,[BX]
OR AL,AL
JNZ X21

;	BX _ _i
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;
X21:
JR X20
X18:

;   return (100);
MOV BX,064X
MOV SP,BP
POP BP
RET;

;   };

; int

; InstanceToMachine(instance)
_InstanceToMachine:

;   struct ShortSTRING *instance;
PUSH BP
MOV BP,SP
PUSH BX

;   { /* parses fixed-form net address*/

;   int i, net;
ADD SP,0FFFCX

;   i=0;
MOV WORD PTR [BP-4],0

;   net=Num(instance, &i);
;&_i
LEA BX,[BP-4]

;	CX _ _instance
MOV CX,[BP-2]
CALL _Num

;	_net _ BX
POP DX
PUSH BX

;   return((Num(instance, &i)<<8) + net);
;&_i
LEA BX,[BP-4]

;	CX _ _instance
MOV CX,[BP-2]
CALL _Num
MOV CX,8
SAL BX,CX

;	CX _ _net
POP CX
PUSH CX
ADD BX,CX
MOV SP,BP
POP BP
RET;

;   };

; static int

; Num(s, lvChar)
_Num:

;   struct ShortSTRING *s;

;   int *lvChar;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int res, i;

;   char c;
ADD SP,0FFFAX

;   res=0;
MOV WORD PTR [BP-6],0

;   for (i=*lvChar; i<s->length; ++i) {

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

;	_i _ BX
MOV [BP-8],BX
X24:

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

;	CX _ _i
MOV CX,[BP-8]
CMP CX,BX
JGE X23
JR X22
X25:
INC WORD PTR [BP-8]
JR X24
X22:

;     c = s->text[i];

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

;	CX _ _i
MOV CX,[BP-8]
ADD BX,CX
MOV AL,[BX]

;	_c _ AL
POP DX
PUSH AX

;     if (c == '#') {

;	AL _ _c
POP AX
PUSH AX
CMP AL,023X
JNZ X26

;       *lvChar=i+1;

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

;	BX _ _lvChar
MOV BX,[BP-4]
MOV [BX],CX

;       return(res);

;	BX _ _res
MOV BX,[BP-6]
MOV SP,BP
POP BP
RET;

;       };
X26:

;     if ('0' > c || c > '7') break;

;	AL _ _c
POP AX
PUSH AX
MOV CL,030X
CMP CL,AL
JG X29

;	AL _ _c
POP AX
PUSH AX
CMP AL,037X
X29:
X28:
JLE X27
JR X23
X27:

;     res = (res<<3) + c - '0';
MOV CX,3

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

;	AL _ _c
POP AX
PUSH AX
ADD AL,0D0X
XOR AH,AH
ADD BX,AX

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

;     if (res > 0377) break;

;	BX _ _res
MOV BX,[BP-6]
CMP BX,0FFX
JLE X30
JR X23
X30:

;     };
JR X25
X23:

;   SIGNAL(ERROR, 0);
XOR BX,BX
MOV CX,2
CALL _SIGNAL

;   };
MOV SP,BP
POP BP
RET;

; int StringSize(s)
_StringSize:

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

;   {

;   return(lenShortSTRING+(s->length+1)/2);

;	DI _ _s
POP DI
PUSH DI
MOV BX,[DI]
INC BX
SAR BX
INC BX
INC BX
MOV SP,BP
POP BP
RET;

;   };

; int StringSizeN(n)
_StringSizeN:

;   int n;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   return(lenShortSTRING+(n+1)/2);

;	BX _ _n
POP BX
PUSH BX
INC BX
SAR BX
INC BX
INC BX
MOV SP,BP
POP BP
RET;

;   };

; int *GetSigVec()
_GetSigVec:
PUSH BP
MOV BP,SP

;   {

;   struct RPCCtx *CtxRunning;
PUSH DX

;   CtxRunning = CurrentContext();
CALL _CurrentContext

;	_CtxRunning _ BX
POP DX
PUSH BX

;   return(CtxRunning->user.sigVec);

;	BX _ _CtxRunning
POP BX
PUSH BX
ADD BX,01CX
MOV SP,BP
POP BP
RET;

;   };

; StartNProcess(name, ctxQ, proc, len, sigVecLen)
_StartNProcess:

;   char *name;

;   struct Queue *ctxQ;

;   int *proc, len, sigVecLen;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int cBase;

;   struct RPCCtx *context;
ADD SP,0FFFCX

;   cBase = (int) GetFixed(len);

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

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

;   len = len - (sigVecLen + lenRPCCtx + 3); /* 3 for slop */

;	BX _ _sigVecLen
MOV BX,[BP-4]
ADD BX,011X

;	CX _ _len
MOV CX,[BP-2]
SUB CX,BX

;	_len _ CX
MOV [BP-2],CX

;   context = InitNContext(name, cBase, len, proc);

;	BX _ _name
MOV BX,[BP+8]
PUSH BX

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

;	BX _ _proc
MOV BX,[BP+4]

;	CX _ _len
MOV CX,[BP-2]
CALL _InitNContext
ADD SP,4

;	_context _ BX
POP DX
PUSH BX

;   context->user.myPSB = NewPSB(context);

;	BX _ _context
POP BX
PUSH BX
PUSH BX

;	BX _ _context
MOV BX,[BP-8]
CALL _NewPSB
MOV CX,BX
POP BX
MOV [BX+26],CX

;   SigInit(context->user.sigVec, sigVecLen, &GetSigVec);

;	BX _ _context
POP BX
PUSH BX
ADD BX,01CX
PUSH BX
MOV BX,OFFSET _GetSigVec

;	CX _ _sigVecLen
MOV CX,[BP-4]
CALL _SigInit
POP DX

;   Enqueue(ctxQ, context);

;	BX _ _context
POP BX
PUSH BX

;	CX _ _ctxQ
MOV CX,[BP+6]
CALL _Enqueue

;   };
MOV SP,BP
POP BP
RET;

; struct ShortSTRING

; /*[Un]Mar*/ *ShallString(dest, src, how)
_ShallString:

;   struct ShortSTRING *dest, *src;

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

;   {

;   int ln;

;   if (src==0) return 0;
PUSH DX

;	BX _ _src
MOV BX,[BP-2]
OR BX,BX
JNZ X31
XOR BX,BX
MOV SP,BP
POP BP
RET;
X31:

;   ln = src->length;

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

;	_ln _ BX
POP DX
PUSH BX

;   if ((how&2)!=0) ln = swab(ln); /* source is big-endian */

;	BX _ _how
MOV BX,[BP-4]
AND BX,2
OR BX,BX
JZ X32

;	BX _ _ln
POP BX
PUSH BX
CALL _swab

;	_ln _ BX
POP DX
PUSH BX
X32:

;   ln = (ln+5)/2; /* now word count */

;	BX _ _ln
POP BX
ADD BX,5
SAR BX

;	_ln _ BX
PUSH BX

;   if (dest == 0) dest = (struct ShortSTRING *) GetFixed(ln);

;	BX _ _dest
MOV BX,[BP+4]
OR BX,BX
JNZ X33

;	BX _ _ln
POP BX
PUSH BX
CALL _GetFixed

;	_dest _ BX
MOV [BP+4],BX
X33:

;   MoveBlock(dest, src, ln);

;	BX _ _dest
MOV BX,[BP+4]
PUSH BX

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

;	CX _ _src
MOV CX,[BP-2]
CALL _MoveBlock
POP DX

;   switch (how) {

;	BX _ _how
MOV BX,[BP-4]
JR X34

;     case 1: case 2:
X36:
X37:

;       dest->length = swab(dest->length);

;	DI _ _dest
MOV DI,[BP+4]
MOV BX,[DI]
CALL _swab
MOV CX,BX

;	BX _ _dest
MOV BX,[BP+4]
MOV [BX],CX

;     default: {};
X38:

;     };
JR X35
X34:
MOV AL,BH
OR AL,AL
JNZ X38
MOV AL,BL
CMP AL,1
JZ X36
CMP AL,2
JZ X37
JR X38
X35:

;   dest->maxLength = dest->length;

;	BX _ _dest
MOV BX,[BP+4]

;	DI _ _dest
MOV DI,[BP+4]
MOV CX,[DI]
MOV [BX+2],CX

;   Block();
CALL _Block

;   return (dest);

;	BX _ _dest
MOV BX,[BP+4]
MOV SP,BP
POP BP
RET;

;   };

; int DoubleComp(px, py)
_DoubleComp:

;   int px[], py[];
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int pt0, pt[2];
ADD SP,0FFFAX

;   Move2(pt, px);

;	BX _ _px
MOV BX,[BP-2]
;&_pt
LEA CX,[BP-10]
CALL _Move2

;   pt0 = DoubleDiff(pt, py);

;	BX _ _py
MOV BX,[BP-4]
;&_pt
LEA CX,[BP-10]
CALL _DoubleDiff

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

;   if (pt[1]==0) {

;	BX _ _pt+2
MOV BX,[BP-8]
OR BX,BX
JNZ X39

;     if (pt0>=0) return (pt0);

;	BX _ _pt0
MOV BX,[BP-6]
CMP BX,0
JL X40

;	BX _ _pt0
MOV BX,[BP-6]
MOV SP,BP
POP BP
RET;
X40:

;     return (maxV);
MOV BX,07FFFX
MOV SP,BP
POP BP
RET;

;     };
X39:

;   if (pt[1]==-1) {

;	BX _ _pt+2
MOV BX,[BP-8]
CMP BX,0FFFFX
JNZ X41

;     if (pt0<0) return (pt0);

;	BX _ _pt0
MOV BX,[BP-6]
CMP BX,0
JGE X42

;	BX _ _pt0
MOV BX,[BP-6]
MOV SP,BP
POP BP
RET;
X42:

;     return (minV);
MOV BX,08001X
MOV SP,BP
POP BP
RET;

;     };
X41:

;   if (pt[1]>0) return (maxV);

;	BX _ _pt+2
MOV BX,[BP-8]
CMP BX,0
JLE X43
MOV BX,07FFFX
MOV SP,BP
POP BP
RET;
X43:

;   /* if (pt[1]<-1) */ return (minV);
MOV BX,08001X
MOV SP,BP
POP BP
RET;

;   };

; Externals Declared Here
PUBLIC _AppendString
PUBLIC _EquivalentStrings
PUBLIC _CStringToString
PUBLIC _StringSizeN
PUBLIC _InstanceToMachine
PUBLIC _StringSize
PUBLIC _GetSigVec
PUBLIC _StartNProcess
PUBLIC _ShallString
PUBLIC _DoubleComp

C_CODE ENDS

; Number of Bytes of Code = 03CCX, (972)