;Alto->8086 small-c compiler rev 2.0
C←CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(wf.DEC)

ASSUME CS:C←CODE, DS:C←DATA

; #include <Env.h>

; extern PutChar();

; extern Block();

; extern IsDigit();

; extern Ugt();

; extern UDiv();

; extern URem();

; wf(fmt)
←wf:

;   char *fmt;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   while (*fmt != 0) PutChar(*fmt++);
X1:

;	DI ← ←fmt
POP DI
PUSH DI
MOV AL,[DI]
OR AL,AL
JZ X2
INC WORD PTR [BP-2]

;	BX ← ←fmt
POP BX
PUSH BX
MOV AL,[BX-1]
CBW
MOV BX,AX
CALL ←PutChar
JR X1
X2:

;   };
MOV SP,BP
POP BP
RET;

; wfcr()
←wfcr:
 CALL StkChk
PUSH BP
MOV BP,SP

;   {

;   wf("\r");
MOV BX,"↑"
CALL ←wf

;   };
MOV SP,BP
POP BP
RET;

; wf1(fmt, a1)
←wf1:

;   char *fmt;

;   int a1;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   pfary(fmt, &a1);
;&←a1
LEA BX,[BP-4]

;	CX ← ←fmt
MOV CX,[BP-2]
CALL ←pfary

;   };
MOV SP,BP
POP BP
RET;

; wf2(fmt, a1, a2)
←wf2:

;   char *fmt;

;   int a1, a2;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int ary[2];
ADD SP,0FFFCX

;   ary[0] = a1;

;	BX ← ←a1
MOV BX,[BP-2]

;	←ary ← BX
POP DX
PUSH BX

;   ary[1] = a2;

;	BX ← ←a2
MOV BX,[BP-4]

;	←ary+2 ← BX
MOV [BP-6],BX

;   pfary(fmt, ary);
;&←ary
LEA BX,[BP-8]

;	CX ← ←fmt
MOV CX,[BP+4]
CALL ←pfary

;   };
MOV SP,BP
POP BP
RET;

; wf3(fmt, a1, a2, a3)
←wf3:

;   char *fmt;

;   int a1, a2, a3;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int ary[3];
ADD SP,0FFFAX

;   ary[0] = a1;

;	BX ← ←a1
MOV BX,[BP+4]

;	←ary ← BX
POP DX
PUSH BX

;   ary[1] = a2;

;	BX ← ←a2
MOV BX,[BP-2]

;	←ary+2 ← BX
MOV [BP-8],BX

;   ary[2] = a3;

;	BX ← ←a3
MOV BX,[BP-4]

;	←ary+4 ← BX
MOV [BP-6],BX

;   pfary(fmt, ary);
;&←ary
LEA BX,[BP-10]

;	CX ← ←fmt
MOV CX,[BP+6]
CALL ←pfary

;   };
MOV SP,BP
POP BP
RET;

; wf4(fmt, a1, a2, a3, a4)
←wf4:

;   char *fmt;

;   int a1, a2, a3, a4;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int ary[4];
ADD SP,0FFF8X

;   ary[0] = a1;

;	BX ← ←a1
MOV BX,[BP+6]

;	←ary ← BX
POP DX
PUSH BX

;   ary[1] = a2;

;	BX ← ←a2
MOV BX,[BP+4]

;	←ary+2 ← BX
MOV [BP-10],BX

;   ary[2] = a3;

;	BX ← ←a3
MOV BX,[BP-2]

;	←ary+4 ← BX
MOV [BP-8],BX

;   ary[3] = a4;

;	BX ← ←a4
MOV BX,[BP-4]

;	←ary+6 ← BX
MOV [BP-6],BX

;   pfary(fmt, ary);
;&←ary
LEA BX,[BP-12]

;	CX ← ←fmt
MOV CX,[BP+8]
CALL ←pfary

;   };
MOV SP,BP
POP BP
RET;

; static pfary(fmt, ary)
←pfary:

;   char *fmt;

;   int *ary;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   char c;

;   while ((c = *fmt++) != 0) {
PUSH DX
X3:
INC WORD PTR [BP-2]

;	BX ← ←fmt
MOV BX,[BP-2]
MOV AL,[BX-1]

;	←c ← AL
POP DX
PUSH AX
OR AL,AL
JZ X4

;     Block();
CALL ←Block

;     if (c == '%') fmt = doone(fmt, *ary++);

;	AL ← ←c
POP AX
PUSH AX
CMP AL,025X
JNZ X5
ADD WORD PTR [BP-4],2

;	BX ← ←ary
MOV BX,[BP-4]
MOV CX,[BX-2]
MOV BX,CX

;	CX ← ←fmt
MOV CX,[BP-2]
CALL ←doone

;	←fmt ← BX
MOV [BP-2],BX

;     else PutChar(c);
JR X6
X5:

;	AX ← ←c
POP AX
PUSH AX
CBW
MOV BX,AX
CALL ←PutChar
X6:

;     };
JR X3
X4:

;   };
MOV SP,BP
POP BP
RET;

; static char *doone(fmt, a1)
←doone:

;   char *fmt;

;   int a1;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   char c, fillchar, *last;

;   char buf[20];

;   int width, radix, i;
ADD SP,0FFE0X

;   fillchar = ' ';
MOV BYTE PTR [BP-8],020X

;   buf[0] = 0;
MOV BYTE PTR [BP-30],0

;   width = 0;
MOV WORD PTR [BP-32],0

;   if (*fmt == '0') fillchar = '0';

;	DI ← ←fmt
MOV DI,[BP-2]
MOV AL,[DI]
CMP AL,030X
JNZ X7
MOV BYTE PTR [BP-8],030X
X7:

;   while ((c = *fmt++) != 0) {
X8:
INC WORD PTR [BP-2]

;	BX ← ←fmt
MOV BX,[BP-2]
MOV AL,[BX-1]

;	←c ← AL
MOV [BP-6],AL
OR AL,AL
JZ X9

;     if (IsDigit(c)) width = (width * 10) + (c - '0');

;	AX ← ←c
MOV AX,[BP-6]
CBW
MOV BX,AX
CALL ←IsDigit
OR BX,BX
JZ X10

;	BX ← ←width
MOV BX,[BP-32]
MOV AX,BX
MOV BX,0AX
IMUL AX,BX

;	CL ← ←c
MOV CL,[BP-6]
ADD CL,0D0X
XOR CH,CH
ADD AX,CX

;	←width ← AX
MOV [BP-32],AX

;     else break;
JR X11
X10:
JR X9
X11:

;     };
JR X8
X9:

;   if (c == 'r') { ssw(a1); return(fmt); };

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,072X
JNZ X12

;	BX ← ←a1
MOV BX,[BP-4]
CALL ←ssw

;	BX ← ←fmt
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
X12:

;   if (c == 's') { wf(a1); return(fmt); };

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,073X
JNZ X13

;	BX ← ←a1
MOV BX,[BP-4]
CALL ←wf

;	BX ← ←fmt
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
X13:

;   if (c == 'c') { PutChar(a1); return(fmt); };

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,063X
JNZ X14

;	BX ← ←a1
MOV BX,[BP-4]
CALL ←PutChar

;	BX ← ←fmt
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
X14:

;   if (c == 'd') radix = -10;

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,064X
JNZ X15
MOV WORD PTR [BP-34],0FFF6X
X15:

;   if (c == 'u') radix = 10;

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,075X
JNZ X16
MOV WORD PTR [BP-34],0AX
X16:

;   if (c == 'x') radix = 16;

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,078X
JNZ X17
MOV WORD PTR [BP-34],010X
X17:

;   if (c == 'o') radix = 8;

;	AL ← ←c
MOV AL,[BP-6]
CMP AL,06FX
JNZ X18
MOV WORD PTR [BP-34],8
X18:

;   if (radix==0) return(fmt);

;	BX ← ←radix
MOV BX,[BP-34]
OR BX,BX
JNZ X19

;	BX ← ←fmt
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;
X19:

;   last = putfnum(buf, a1, radix);
;&←buf
LEA BX,[BP-30]
PUSH BX

;	BX ← ←radix
MOV BX,[BP-34]

;	CX ← ←a1
MOV CX,[BP-4]
CALL ←putfnum
POP DX

;	←last ← BX
MOV [BP-10],BX

;   if (width>0) {

;	BX ← ←width
MOV BX,[BP-32]
CMP BX,0
JLE X20

;     width -= (last-buf);
;&←buf
LEA BX,[BP-30]

;	CX ← ←last
MOV CX,[BP-10]
SUB CX,BX
SUB [BP-32],CX

;     while (width > 0) {
X21:

;	BX ← ←width
MOV BX,[BP-32]
CMP BX,0
JLE X22

;       Block();
CALL ←Block

;       PutChar(fillchar);

;	AX ← ←fillchar
MOV AX,[BP-8]
CBW
MOV BX,AX
CALL ←PutChar

;       width -= 1;
DEC WORD PTR [BP-32]

;       };
JR X21
X22:

;     };
X20:

;   wf(buf);
;&←buf
LEA BX,[BP-30]
CALL ←wf

;   return(fmt);

;	BX ← ←fmt
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;

;   };

; static ssw(s)
←ssw:

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

;   {

;   int i;

;   for (i = 0; i < s->length; i += 1) PutChar(s->text[i]);
PUSH DX
MOV WORD PTR [BP-4],0
X25:

;	DI ← ←s
MOV DI,[BP-2]
MOV BX,[DI]

;	CX ← ←i
POP CX
PUSH CX
CMP CX,BX
JGE X24
JR X23
X26:
INC WORD PTR [BP-4]
JR X25
X23:

;	BX ← ←s
MOV BX,[BP-2]
ADD BX,4

;	CX ← ←i
POP CX
PUSH CX
ADD BX,CX
MOV AL,[BX]
CBW
MOV BX,AX
CALL ←PutChar
JR X26
X24:

;   };
MOV SP,BP
POP BP
RET;

; static char *putfnum(buf, a1, radix)
←putfnum:

;   char *buf;

;   int a1, radix;
 CALL StkChk
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int digit;

;   if (radix<0) {
PUSH DX

;	BX ← ←radix
MOV BX,[BP-4]
CMP BX,0
JGE X27

;     radix = -radix;

;	BX ← ←radix
MOV BX,[BP-4]
NEG BX

;	←radix ← BX
MOV [BP-4],BX

;     if (a1<0) {

;	BX ← ←a1
MOV BX,[BP-2]
CMP BX,0
JGE X28

;       a1 = -a1;

;	BX ← ←a1
MOV BX,[BP-2]
NEG BX

;	←a1 ← BX
MOV [BP-2],BX

;       *buf++ = '-';
INC WORD PTR [BP+4]

;	BX ← ←buf
MOV BX,[BP+4]
MOV BYTE PTR [BX-1],02DX

;       };
X28:

;     };
X27:

;   if (!Ugt(radix, a1)) buf = putfnum(buf, UDiv(a1, radix), radix);

;	BX ← ←a1
MOV BX,[BP-2]

;	CX ← ←radix
MOV CX,[BP-4]
CALL ←Ugt
OR BX,BX
JNZ X29

;	BX ← ←buf
MOV BX,[BP+4]
PUSH BX

;	BX ← ←radix
MOV BX,[BP-4]

;	CX ← ←a1
MOV CX,[BP-2]
CALL ←UDiv
PUSH BX

;	BX ← ←radix
MOV BX,[BP-4]
POP CX
CALL ←putfnum
POP DX

;	←buf ← BX
MOV [BP+4],BX
X29:

;   digit = URem(a1, radix);

;	BX ← ←radix
MOV BX,[BP-4]

;	CX ← ←a1
MOV CX,[BP-2]
CALL ←URem

;	←digit ← BX
POP DX
PUSH BX

;   if (digit>9) *buf++ = digit + 'A'-10;

;	BX ← ←digit
POP BX
PUSH BX
CMP BX,9
JLE X30
INC WORD PTR [BP+4]

;	BX ← ←buf
MOV BX,[BP+4]

;	CX ← ←digit
POP CX
PUSH CX
ADD CX,037X
MOV [BX-1],CL

;   else *buf++ = digit + '0';
JR X31
X30:
INC WORD PTR [BP+4]

;	BX ← ←buf
MOV BX,[BP+4]

;	CX ← ←digit
POP CX
PUSH CX
ADD CX,030X
MOV [BX-1],CL
X31:

;   *buf = 0;

;	BX ← ←buf
MOV BX,[BP+4]
MOV BYTE PTR [BX],0

;   return(buf);

;	BX ← ←buf
MOV BX,[BP+4]
MOV SP,BP
POP BP
RET;

;   };

; Externals Declared Here
PUBLIC ←wf
PUBLIC ←wfcr
PUBLIC ←wf1
PUBLIC ←wf2
PUBLIC ←wf3
PUBLIC ←wf4

C←CODE ENDS

; Number of Bytes of Code = 02DBX, (731)