[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: Re-engineered: Wizardry III, Legacy of Llylgamyn
In this post, I will give more examples of the output from my pcode
decompiler, Wiz4, and some of the interesting problems you might run
into. The programs at the end of this post were taken from Hyde
chapter 4.
In order to understand how to re-engineer Pascal pcode, you should
probably first study sample Pascal programs and the pcode generated
from them.
There are 2 different de-compilers (de-coders?) used in Hyde, but I
think mine, Wiz4, displays the information a little better, even if it
is a bit inconsistent in places.
The description fields for Wiz4 are a bit of a mish-mash of different
programming languages. If I were to write a new de-compiler for
others to use, I would make the description fields a bit more
consistent with a single known programming language such as Pascal or
C.
Definition of terms used in my de-compiler output
=================================================
BYTE
----
8 bit value
WORD
----
Two consecutive BYTES, usually starting on an even byte boundary and
in little-endian notation.
BASE
----
BASE Procedure. A pointer to the activation record of the most
recently invoked base procedure (lex level 0). Global (lex level 0)
variables are accessed by indexing off BASE. (as described in Apple
Pascal OS)
In Wiz4, BASE.03 represents the first global variable. The value
following "BASE." is the word offset in hexidecimal to the global
variable. If I were to re-write Wiz4, I might instead use a notation
such as "BASE^.G03". I'm not sure why I have chosen 03 to represent
the first global variable instead of using 01 or 00.
MP
--
Markstack Pointer. This is similar to BASE, except that it refers to
the variables in a Procedure (or Function) or to the passed
parameters. MP.01 represents the first declared variable in a
procedure with no passed parameters.
TOS
---
Top of Stack. (TOS) is my way of referring to the value stored on
TOS.
Once again, I am a bit inconsistent in Wiz4. I use "(TOS)" to
represent the value that is found at the top of the stack. It would
probably make more sense to have instead used "TOS^.0", and perhaps
"TOS^.1" or "TOS^.-1" to represent the previous TOS value.
(TOS) or (TOS-1)
----------------
If the 2 values on the top of the stack represent integers, then (TOS)
is the value of the integer at the top of the stack, and (TOS-1) is
the value of the next integer in the stack.
If the 2 values on the top of the stack represent other sized values,
then (TOS) refers to the top value, and (TOS-1) refers to the next.
(TOS-1)^ := (TOS)^ 02 WORDS
---------------------------
A construct like this says to use (TOS) and (TOS-1) as pointers and to
transfer 2 words pointed to by (TOS) to the address (TOS-1). Some of
my descriptions use "BT" which stands for "Block Transfer".
PUSH #0004
----------
Push the value 04 on to the stack (1 word).
PUSH BASE.03
------------
Push the value of the variable BASE.03 on to the stack.
PUSH #BASE.03
-------------
Push the address of BASE.03 on to the stack.
STRING instructions in code
---------------------------
5005 A6 0B 48 45 4C 4C 4F 20 54 48 45 52 45
HELLO THERE
LSA. PUSH #(PC+1) POINTER TO THE STRING
First the hex values of the characters are displayed,then the next
line displays the ASCII representation,and the final line has the
instruction. In this case, the pointer to the string is pushed onto
the stack (using the program counter). Note the first byte is the
length of the string, and that the string is not "null terminated".
SAS instruction
---------------
5012 AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
This instruction is a bit strange, since it operates differently based
upon the value that is currently on the top of stack. If it is a
character, then use (TOS-1) as a pointer, and transfer the character.
If it is a pointer to a string, then use the pointer to transfer the
string (TOS-1).
First 2 instructions NOP
------------------------
You might notice that the first 2 instructions for most procedures are
simply NOPs. The compiler was written as a single pass compiler, but
they needed to account for the possible loading of intrinsic
segments. Intrinsic segments must be loaded before any of the rest of
the code in the procedure is executed, but the compiler doesn't know
that until it gets to an instruction that requires the intrinsic
segment. When an intrinsic segment needs to be loaded, the NOPs are
changed to a GOTO instruction. See for example, HYDE4-19.
[Side note: In a bit of irony, the first instruction executed by the
pcode "machine" during the boot process is a GOTO instruction to load
an intrinsic segment.]
Instructions following RBP
--------------------------
You might also notice that following the exit (RBP) statement in a
procedure that Wiz4 usually displays a few more "instructions". These
are not instructions, but are the "jump table" values for the
procedure. During my re-engineering of Legacy of Llylgamyn I realized
that I could have re-constructed the pcode correctly from the
beginning of the procedure through the RBP instruction, but still not
have correctly written the Pascal code, with the only difference being
in these bytes that follow the RBP instruction. Consider the
following 2 programs:
PROGRAM BIGJUMP1;
VAR
A : INTEGER;
BEGIN
IF TRUE THEN
BEGIN
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 2
END;
END.
PROGRAM BIGJUMP2;
VAR
A : INTEGER;
BEGIN
IF TRUE THEN
BEGIN
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20;
A := 1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20
END;
A := 2
END.
The pcodes generated from BIGJUMP1 and BIGJUMP2 are identical from the
first instruction down through the RBP instruction. They only differ
in the "jump table" values that follow the RBP instruction.
LDC instruction
---------------
Earlier today I noticed the LDC pcode instruction seems to display
differently at times. Then I realized that it is operating with WORD
values and needs to have them aligned on an even BYTE boundary. For
example:
5004 B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5017 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
Record structures and pcode
---------------------------
Re-engineering pcode that was created from Pascal code written with
user defined structures (RECORDs)is a very error prone task and will
often require re-working of re-engineered Pascal code that you thought
you had properly re-engineered. Take for example the following pcode:
JTAB FOR SUBROUTINE 1:
DATA SIZE: 16
PARAM SIZE: 4
EXIT AT: 5022
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 01 SLDC. PUSH #0001
5003 AB 03 SRO. BASE.03 := (TOS)
5005 02 SLDC. PUSH #0002
5006 AB 04 SRO. BASE.04 := (TOS)
5008 01 SLDC. PUSH #0001
5009 AB 05 SRO. BASE.05 := (TOS)
500B 00 SLDC. PUSH #0000
500C AB 06 SRO. BASE.06 := (TOS)
500E A5 07 LA0. PUSH #BASE.07
5010 B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5016 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5018 A5 09 LA0. PUSH #BASE.09
501A B3 02 0C 40 CD CC
LDC. PUSH 02 WORDS
5020 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5022 C1 00 RBP. RETURN FROM BASE PROCEDURE.
The following 2 programs (TEST3 and TEST2) BOTH generate the pcode
above:
PROGRAM TEST3;
VAR
A1 : INTEGER;
A2 : INTEGER;
B1 : BOOLEAN;
B2 : BOOLEAN;
R1 : REAL;
R2 : REAL;
BEGIN
A1 := 1;
A2 := 2;
B1 := TRUE;
B2 := FALSE;
R1 := 1.1;
R2 := 2.2
END.
-------------------------
PROGRAM TEST2;
TYPE
ATYPE = RECORD
A1 : INTEGER;
A2 : INTEGER;
B1 : BOOLEAN;
B2 : BOOLEAN;
R1 : REAL;
R2 : REAL;
END;
VAR
A : ATYPE;
BEGIN
A.A1 := 1;
A.A2 := 2;
A.B1 := TRUE;
A.B2 := FALSE;
A.R1 := 1.1;
A.R2 := 2.2
END.
Let's continue with this example a step further. The following pcode
is identical to the above, but 1 more instruction was added at the end
of the Pascal program. Now it is clear that the RECORD structure MUST
be used:
JTAB FOR SUBROUTINE 1:
DATA SIZE: 32
PARAM SIZE: 4
EXIT AT: 5028
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 01 SLDC. PUSH #0001
5003 AB 03 SRO. BASE.03 := (TOS)
5005 02 SLDC. PUSH #0002
5006 AB 04 SRO. BASE.04 := (TOS)
5008 01 SLDC. PUSH #0001
5009 AB 05 SRO. BASE.05 := (TOS)
500B 00 SLDC. PUSH #0000
500C AB 06 SRO. BASE.06 := (TOS)
500E A5 07 LA0. PUSH #BASE.07
5010 B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5016 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5018 A5 09 LA0. PUSH #BASE.09
501A B3 02 0C 40 CD CC
LDC. PUSH 02 WORDS
5020 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5022 A5 0B LA0. PUSH #BASE.0B
5024 A5 03 LA0. PUSH #BASE.03
5026 A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
5028 C1 00 RBP. RETURN FROM BASE PROCEDURE.
Wiz4 Examples using Hyde chapter 4
==================================
PROGRAM ALLOCATION_EXAMPLES; (* HYDE41 *)
VAR
I : INTEGER;
A : ARRAY [0..15] OF INTEGER;
J : INTEGER;
B : ARRAY [0..127] OF INTEGER;
K : INTEGER;
BEGIN
I := I; (* IN THESE EXAMPLES, NOTE THE *)
J := J; (* NUMBER OF BYTES REQUIRED FOR *)
K := K (* LOAD AND STORING EACH VARIABLE *)
END.
FILE: 24 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 294
PARAM SIZE: 4
EXIT AT: 500F
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 EA SLDO. PUSH BASE.03
5003 AB 03 SRO. BASE.03 := (TOS)
5005 A9 14 LDO. PUSH BASE.14
5007 AB 14 SRO. BASE.14 := (TOS)
5009 A9 80 95 LDO. PUSH BASE.95
500C AB 80 95 SRO. BASE.95 := (TOS)
500F C1 00 RBP. RETURN FROM BASE PROCEDURE.
5011 00 SLDC. PUSH #0000
PROGRAM ALLOCATION_EXAMPLES_REAL; (* HYDE42 *)
VAR
R : REAL;
S : REAL;
BEGIN
R := 1.1; (* ASSIGNING A REAL CONSTANT *)
R := 4; (* ASSIGNING AN INTEGER CONSTANT. *)
R := S; (* ASSIGNING A REAL VARIABLE. *)
R := -1.1; (* ASSIGNING A NEGATIVE REAL CONSTANT. *)
END.
FILE: 25 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 8
PARAM SIZE: 4
EXIT AT: 5025
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 A5 03 LA0. PUSH #BASE.03
5004 B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
500A BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
500C A5 03 LA0. PUSH #BASE.03
500E 04 SLDC. PUSH #0004
500F 8A FLT. PUSH ( REAL(TOS) )
5010 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5012 A5 03 LA0. PUSH #BASE.03
5014 A5 05 LA0. PUSH #BASE.05
5016 BC 02 LDM. PUSH 02 WORDS USING (TOS)^
5018 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
501A A5 03 LA0. PUSH #BASE.03
501C B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5022 92 NGR. PUSH -(TOS)
5023 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5025 C1 00 RBP. RETURN FROM BASE PROCEDURE.
5027 00 SLDC. PUSH #0000
PROGRAM ALLOCATION_EXAMPLES_ARRAYS; (* HYDE43 *)
VAR
I : ARRAY [0..10] OF INTEGER;
R : ARRAY[ 0..10] OF REAL;
J : INTEGER;
BEGIN
J := 1;
I [0] := 0;
R [0] := 1.1;
R [J] := 1.1;
I [J] := J;
END.
FILE: 26 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 68
PARAM SIZE: 4
EXIT AT: 503E
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 01 SLDC. PUSH #0001
5003 AB 24 SRO. BASE.24 := (TOS)
5005 A5 03 LA0. PUSH #BASE.03
5007 00 SLDC. PUSH #0000
5008 00 SLDC. PUSH #0000
5009 0A SLDC. PUSH #000A
500A 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
500B A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
500D 00 SLDC. PUSH #0000
500E 9A STO. (TOS-1)^ := (TOS)
500F A5 0E LA0. PUSH #BASE.0E
5011 00 SLDC. PUSH #0000
5012 00 SLDC. PUSH #0000
5013 0A SLDC. PUSH #000A
5014 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5015 A4 02 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=02
5017 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
501E BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5020 A5 0E LA0. PUSH #BASE.0E
5022 A9 24 LDO. PUSH BASE.24
5024 00 SLDC. PUSH #0000
5025 0A SLDC. PUSH #000A
5026 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5027 A4 02 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=02
5029 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
5030 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5032 A5 03 LA0. PUSH #BASE.03
5034 A9 24 LDO. PUSH BASE.24
5036 00 SLDC. PUSH #0000
5037 0A SLDC. PUSH #000A
5038 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5039 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
503B A9 24 LDO. PUSH BASE.24
503D 9A STO. (TOS-1)^ := (TOS)
503E C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*$R-*)
PROGRAM ALLOCATION_EXAMPLES_ARRAYS; (* HYDE44 *)
VAR
I : ARRAY [0..10] OF INTEGER;
R : ARRAY [0..10] OF REAL;
J : INTEGER;
BEGIN
J := 1;
I [0] := 0;
R [0] := 1.1;
R [J] := 1.1;
I [J] := J;
END.
FILE: 27 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 68
PARAM SIZE: 4
EXIT AT: 5031
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 01 SLDC. PUSH #0001
5003 AB 24 SRO. BASE.24 := (TOS)
5005 A5 03 LA0. PUSH #BASE.03
5007 00 SLDC. PUSH #0000
5008 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
500A 00 SLDC. PUSH #0000
500B 9A STO. (TOS-1)^ := (TOS)
500C A5 0E LA0. PUSH #BASE.0E
500E 00 SLDC. PUSH #0000
500F A4 02 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=02
5011 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
5018 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
501A A5 0E LA0. PUSH #BASE.0E
501C A9 24 LDO. PUSH BASE.24
501E A4 02 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=02
5020 B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5026 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5028 A5 03 LA0. PUSH #BASE.03
502A A9 24 LDO. PUSH BASE.24
502C A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
502E A9 24 LDO. PUSH BASE.24
5030 9A STO. (TOS-1)^ := (TOS)
5031 C1 00 RBP. RETURN FROM BASE PROCEDURE.
5033 00 SLDC. PUSH #0000
PROGRAM ALLOCATION_EXAMPLES_SETS; (* HYDE45 *)
TYPE
SMALLI = 0..11;
VAR
S : SET OF SMALLI;
R : SET OF SMALLI;
Q : SET OF SMALLI;
B : BOOLEAN;
I : INTEGER;
BEGIN
S := []; (* EMPTY SET *)
S := [0];
S := [0,1];
S := [0,1,2];
S := [0,1,2,3];
S := [4,5,6,7];
S := [8,9,10,11];
R := [0];
Q := R + S;
Q := R - S;
Q := R * S;
I := 2;
B := I IN Q;
END.
FILE: 28 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 10
PARAM SIZE: 4
EXIT AT: 5059
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 A0 01 ADJ. ADJ SET TO 01 WORDS
5005 AB 03 SRO. BASE.03 := (TOS)
5007 01 SLDC. PUSH #0001
5008 01 SLDC. PUSH #0001
5009 A0 01 ADJ. ADJ SET TO 01 WORDS
500B AB 03 SRO. BASE.03 := (TOS)
500D 03 SLDC. PUSH #0003
500E 01 SLDC. PUSH #0001
500F A0 01 ADJ. ADJ SET TO 01 WORDS
5011 AB 03 SRO. BASE.03 := (TOS)
5013 07 SLDC. PUSH #0007
5014 01 SLDC. PUSH #0001
5015 A0 01 ADJ. ADJ SET TO 01 WORDS
5017 AB 03 SRO. BASE.03 := (TOS)
5019 0F SLDC. PUSH #000F
501A 01 SLDC. PUSH #0001
501B A0 01 ADJ. ADJ SET TO 01 WORDS
501D AB 03 SRO. BASE.03 := (TOS)
501F C7 F0 00 LDCI. PUSH #00F0
5022 01 SLDC. PUSH #0001
5023 A0 01 ADJ. ADJ SET TO 01 WORDS
5025 AB 03 SRO. BASE.03 := (TOS)
5027 C7 00 0F LDCI. PUSH #0F00
502A 01 SLDC. PUSH #0001
502B A0 01 ADJ. ADJ SET TO 01 WORDS
502D AB 03 SRO. BASE.03 := (TOS)
502F 01 SLDC. PUSH #0001
5030 01 SLDC. PUSH #0001
5031 A0 01 ADJ. ADJ SET TO 01 WORDS
5033 AB 04 SRO. BASE.04 := (TOS)
5035 EB SLDO. PUSH BASE.04
5036 01 SLDC. PUSH #0001
5037 EA SLDO. PUSH BASE.03
5038 01 SLDC. PUSH #0001
5039 9C UNI. UNION OF SETS (TOS) OR (TOS-1)
503A A0 01 ADJ. ADJ SET TO 01 WORDS
503C AB 05 SRO. BASE.05 := (TOS)
503E EB SLDO. PUSH BASE.04
503F 01 SLDC. PUSH #0001
5040 EA SLDO. PUSH BASE.03
5041 01 SLDC. PUSH #0001
5042 85 DIF. DIFFERENCE OF SETS (TOS) AND (TOS-1)
5043 A0 01 ADJ. ADJ SET TO 01 WORDS
5045 AB 05 SRO. BASE.05 := (TOS)
5047 EB SLDO. PUSH BASE.04
5048 01 SLDC. PUSH #0001
5049 EA SLDO. PUSH BASE.03
504A 01 SLDC. PUSH #0001
504B 8C INT. INTERSECTION OF SETS (TOS) AND (TOS-1)
504C A0 01 ADJ. ADJ SET TO 01 WORDS
504E AB 05 SRO. BASE.05 := (TOS)
5050 02 SLDC. PUSH #0002
5051 AB 07 SRO. BASE.07 := (TOS)
5053 EE SLDO. PUSH BASE.07
5054 EC SLDO. PUSH BASE.05
5055 01 SLDC. PUSH #0001
5056 8B INN. PUSH TRUE IF (TOS-1) IN SET (TOS)
5057 AB 06 SRO. BASE.06 := (TOS)
5059 C1 00 RBP. RETURN FROM BASE PROCEDURE.
505B 00 SLDC. PUSH #0000
PROGRAM ALLOCATION_EXAMPLES_SETS; (* HYDE46 *)
TYPE
LARGEI = 0..47;
VAR
S : SET OF LARGEI;
R : SET OF LARGEI;
Q : SET OF LARGEI;
B : BOOLEAN;
I : INTEGER;
BEGIN
S := [];
S := [8,11];
R := [0];
Q := R + S;
Q := R - S;
Q := R * S;
I := 2;
B := I IN Q;
END.
FILE: 29 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 22
PARAM SIZE: 4
EXIT AT: 505A
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 A5 03 LA0. PUSH #BASE.03
5004 00 SLDC. PUSH #0000
5005 A0 03 ADJ. ADJ SET TO 03 WORDS
5007 BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
5009 A5 03 LA0. PUSH #BASE.03
500B C7 00 09 LDCI. PUSH #0900
500E 01 SLDC. PUSH #0001
500F A0 03 ADJ. ADJ SET TO 03 WORDS
5011 BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
5013 A5 06 LA0. PUSH #BASE.06
5015 01 SLDC. PUSH #0001
5016 01 SLDC. PUSH #0001
5017 A0 03 ADJ. ADJ SET TO 03 WORDS
5019 BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
501B A5 09 LA0. PUSH #BASE.09
501D A5 06 LA0. PUSH #BASE.06
501F BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5021 03 SLDC. PUSH #0003
5022 A5 03 LA0. PUSH #BASE.03
5024 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5026 03 SLDC. PUSH #0003
5027 9C UNI. UNION OF SETS (TOS) OR (TOS-1)
5028 A0 03 ADJ. ADJ SET TO 03 WORDS
502A BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
502C A5 09 LA0. PUSH #BASE.09
502E A5 06 LA0. PUSH #BASE.06
5030 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5032 03 SLDC. PUSH #0003
5033 A5 03 LA0. PUSH #BASE.03
5035 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5037 03 SLDC. PUSH #0003
5038 85 DIF. DIFFERENCE OF SETS (TOS) AND (TOS-1)
5039 A0 03 ADJ. ADJ SET TO 03 WORDS
503B BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
503D A5 09 LA0. PUSH #BASE.09
503F A5 06 LA0. PUSH #BASE.06
5041 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5043 03 SLDC. PUSH #0003
5044 A5 03 LA0. PUSH #BASE.03
5046 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5048 03 SLDC. PUSH #0003
5049 8C INT. INTERSECTION OF SETS (TOS) AND (TOS-1)
504A A0 03 ADJ. ADJ SET TO 03 WORDS
504C BD 03 STM. (TOS-1)^ := (TOS)^ 03 WORDS
504E 02 SLDC. PUSH #0002
504F AB 0D SRO. BASE.0D := (TOS)
5051 F4 SLDO. PUSH BASE.0D
5052 A5 09 LA0. PUSH #BASE.09
5054 BC 03 LDM. PUSH 03 WORDS USING (TOS)^
5056 03 SLDC. PUSH #0003
5057 8B INN. PUSH TRUE IF (TOS-1) IN SET (TOS)
5058 AB 0C SRO. BASE.0C := (TOS)
505A C1 00 RBP. RETURN FROM BASE PROCEDURE.
PROGRAM ALLOCATION_EXAMPLES_RECORDS; (* HYDE47 *)
TYPE
MYTYPE = RECORD
I : INTEGER;
R : REAL;
B : BOOLEAN;
A : ARRAY[ 0..3] OF CHAR;
END;
VAR
M : MYTYPE;
N : MYTYPE;
L : ARRAY[ 0..1] OF MYTYPE;
BEGIN
M.I := 0;
M.R := 1.1;
M.B := TRUE;
M.A[ 0] := 'A';
N := M;
L[0] := M;
L[1] := N;
END.
FILE: 30 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 64
PARAM SIZE: 4
EXIT AT: 503B
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 A5 04 LA0. PUSH #BASE.04
5007 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
500E BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5010 01 SLDC. PUSH #0001
5011 AB 06 SRO. BASE.06 := (TOS)
5013 A5 07 LA0. PUSH #BASE.07
5015 00 SLDC. PUSH #0000
5016 00 SLDC. PUSH #0000
5017 03 SLDC. PUSH #0003
5018 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5019 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
501B 41 SLDC. PUSH #0041
501C 9A STO. (TOS-1)^ := (TOS)
501D A5 0B LA0. PUSH #BASE.0B
501F A5 03 LA0. PUSH #BASE.03
5021 A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
5023 A5 13 LA0. PUSH #BASE.13
5025 00 SLDC. PUSH #0000
5026 00 SLDC. PUSH #0000
5027 01 SLDC. PUSH #0001
5028 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5029 A4 08 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=08
502B A5 03 LA0. PUSH #BASE.03
502D A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
502F A5 13 LA0. PUSH #BASE.13
5031 01 SLDC. PUSH #0001
5032 00 SLDC. PUSH #0000
5033 01 SLDC. PUSH #0001
5034 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
5035 A4 08 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=08
5037 A5 0B LA0. PUSH #BASE.0B
5039 A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
503B C1 00 RBP. RETURN FROM BASE PROCEDURE.
503D 00 SLDC. PUSH #0000
(*$R-*)
PROGRAM ALLOCATION_EXAMPLES_RECORDS; (* HYDE48 *)
TYPE
MYTYPE = RECORD
I : INTEGER;
R : REAL;
B : BOOLEAN;
A : ARRAY[ 0..3] OF CHAR;
END;
VAR
M : MYTYPE;
N : MYTYPE;
L : ARRAY[ 0..1] OF MYTYPE;
BEGIN
M.I := 0;
M.R := 1.1;
M.B := TRUE;
M.A[ 0] := 'A';
N := M;
L[0] := M;
L[1] := N;
END.
FILE: 31 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 64
PARAM SIZE: 4
EXIT AT: 5032
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 A5 04 LA0. PUSH #BASE.04
5007 B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
500E BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5010 01 SLDC. PUSH #0001
5011 AB 06 SRO. BASE.06 := (TOS)
5013 A5 07 LA0. PUSH #BASE.07
5015 00 SLDC. PUSH #0000
5016 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
5018 41 SLDC. PUSH #0041
5019 9A STO. (TOS-1)^ := (TOS)
501A A5 0B LA0. PUSH #BASE.0B
501C A5 03 LA0. PUSH #BASE.03
501E A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
5020 A5 13 LA0. PUSH #BASE.13
5022 00 SLDC. PUSH #0000
5023 A4 08 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=08
5025 A5 03 LA0. PUSH #BASE.03
5027 A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
5029 A5 13 LA0. PUSH #BASE.13
502B 01 SLDC. PUSH #0001
502C A4 08 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=08
502E A5 0B LA0. PUSH #BASE.0B
5030 A8 08 MOV. (TOS-1)^ := (TOS)^ BT 08 WORDS
5032 C1 00 RBP. RETURN FROM BASE PROCEDURE.
PROGRAM ALLOCATION_EXAMPLES_STRINGS; (* HYDE49 *)
VAR
S : STRING;
T : STRING;
BEGIN
S := 'HELLO THERE';
T := S;
T := '';
T := 'A';
END.
FILE: 32 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 164
PARAM SIZE: 4
EXIT AT: 5026
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 A5 03 LA0. PUSH #BASE.03
5004 D7 NOP. NOP
5005 A6 0B 48 45 4C 4C 4F 20 54 48 45 52 45
HELLO THERE
LSA. PUSH #(PC+1) POINTER TO THE STRING
5012 AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
5014 A5 2C LA0. PUSH #BASE.2C
5016 A5 03 LA0. PUSH #BASE.03
5018 AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
501A A5 2C LA0. PUSH #BASE.2C
501C D7 NOP. NOP
501D A6 00
*
LSA. PUSH #(PC+1) POINTER TO THE STRING
501F AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
5021 A5 2C LA0. PUSH #BASE.2C
5023 41 SLDC. PUSH #0041
5024 AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
5026 C1 00 RBP. RETURN FROM BASE PROCEDURE.
PROGRAM ALLOCATION_EXAMPLES_POINTERS; (* HYDE410 *)
VAR
P : ^INTEGER;
Q : ^INTEGER;
I : INTEGER;
BEGIN
I := P^;
P^ := I;
P := Q;
END.
FILE: 33 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 6
PARAM SIZE: 4
EXIT AT: 500C
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 EA SLDO. PUSH BASE.03
5003 F8 SIND. PUSH (TOS)^.0
5004 AB 05 SRO. BASE.05 := (TOS)
5006 EA SLDO. PUSH BASE.03
5007 EC SLDO. PUSH BASE.05
5008 9A STO. (TOS-1)^ := (TOS)
5009 EB SLDO. PUSH BASE.04
500A AB 03 SRO. BASE.03 := (TOS)
500C C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*R-*)
PROGRAM FOR_LOOP_EXAMPLE; (* HYDE411 *)
VAR
I : INTEGER;
A : ARRAY[ 0..127] OF INTEGER;
BEGIN
FOR I := 0 TO 127 DO A[I] := I;
END.
FILE: 34 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 260
PARAM SIZE: 4
EXIT AT: 501E
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 7F SLDC. PUSH #007F
5006 AB 80 84 SRO. BASE.84 := (TOS)
5009 EA SLDO. PUSH BASE.03
500A A9 80 84 LDO. PUSH BASE.84
500D C8 LEQI. PUSH ((TOS-1) <= (TOS))
500E A1 0E UJP. IF NOT (TOS) THEN JUMP TO 501E
5010 A5 04 LA0. PUSH #BASE.04
5012 EA SLDO. PUSH BASE.03
5013 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
5015 EA SLDO. PUSH BASE.03
5016 9A STO. (TOS-1)^ := (TOS)
5017 EA SLDO. PUSH BASE.03
5018 01 SLDC. PUSH #0001
5019 82 ADI. PUSH ((TOS) + (TOS-1))
501A AB 03 SRO. BASE.03 := (TOS)
501C B9 F6 UJP. JUMP TO 5009
501E C1 00 RBP. RETURN FROM BASE PROCEDURE.
5020 17 SLDC. PUSH #0017
5021 00 SLDC. PUSH #0000
(*$R-*)
PROGRAM WHILE_LOOP_EXAMPLE; (* HYDE 412 *)
VAR
I : INTEGER;
A : ARRAY[ 0..127] OF INTEGER;
BEGIN
I := 0;
WHILE (I <=127) DO
BEGIN
A[I] := I;
I := I + 1
END;
END.
FILE: 35 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 258
PARAM SIZE: 4
EXIT AT: 5018
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 EA SLDO. PUSH BASE.03
5006 7F SLDC. PUSH #007F
5007 C8 LEQI. PUSH ((TOS-1) <= (TOS))
5008 A1 0E UJP. IF NOT (TOS) THEN JUMP TO 5018
500A A5 04 LA0. PUSH #BASE.04
500C EA SLDO. PUSH BASE.03
500D A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
500F EA SLDO. PUSH BASE.03
5010 9A STO. (TOS-1)^ := (TOS)
5011 EA SLDO. PUSH BASE.03
5012 01 SLDC. PUSH #0001
5013 82 ADI. PUSH ((TOS) + (TOS-1))
5014 AB 03 SRO. BASE.03 := (TOS)
5016 B9 F6 UJP. JUMP TO 5005
5018 C1 00 RBP. RETURN FROM BASE PROCEDURE.
501A 15 SLDC. PUSH #0015
501B 00 SLDC. PUSH #0000
(*$R-*)
PROGRAM REPEAT_LOOP_EXAMLE; (* HYDE413 *)
VAR
I : INTEGER;
A : ARRAY[ 0..127] OF INTEGER;
BEGIN
I := 0;
REPEAT
A[I] := I;
I := I + 1;
UNTIL (I > 127);
END.
FILE: 36 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 258
PARAM SIZE: 4
EXIT AT: 5016
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 A5 04 LA0. PUSH #BASE.04
5007 EA SLDO. PUSH BASE.03
5008 A4 01 IXA. PUSH #((TOS-1)[TOS]). ARRAY SIZE=01
500A EA SLDO. PUSH BASE.03
500B 9A STO. (TOS-1)^ := (TOS)
500C EA SLDO. PUSH BASE.03
500D 01 SLDC. PUSH #0001
500E 82 ADI. PUSH ((TOS) + (TOS-1))
500F AB 03 SRO. BASE.03 := (TOS)
5011 EA SLDO. PUSH BASE.03
5012 7F SLDC. PUSH #007F
5013 C5 GRTI. PUSH ((TOS-1) > (TOS))
5014 A1 F6 UJP. IF NOT (TOS) THEN JUMP TO 5005
5016 C1 00 RBP. RETURN FROM BASE PROCEDURE.
5018 13 SLDC. PUSH #0013
5019 00 SLDC. PUSH #0000
(*$R-*)
PROGRAM IF_STATEMENT; (* HYDE414 *)
VAR
I : INTEGER;
BEGIN
IF I = 0 THEN
I := -1
ELSE
I := 0;
IF (I <> 0) THEN
I := 0;
IF (I >= 0) THEN
I := -1;
IF (I > 0) THEN
I := 0;
IF (I < 0) THEN
I := 0
ELSE
I := 1
END.
FILE: 37 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 2
PARAM SIZE: 4
EXIT AT: 503E
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 EA SLDO. PUSH BASE.03
5003 00 SLDC. PUSH #0000
5004 C3 EQUI. PUSH ((TOS-1) = (TOS))
5005 A1 06 UJP. IF NOT (TOS) THEN JUMP TO 500D
5007 01 SLDC. PUSH #0001
5008 91 NGI. PUSH -(TOS) (2'S COMP)
5009 AB 03 SRO. BASE.03 := (TOS)
500B B9 03 UJP. JUMP TO 5010
500D 00 SLDC. PUSH #0000
500E AB 03 SRO. BASE.03 := (TOS)
5010 EA SLDO. PUSH BASE.03
5011 00 SLDC. PUSH #0000
5012 CB NEQI. PUSH ((TOS-1) <> (TOS))
5013 A1 03 UJP. IF NOT (TOS) THEN JUMP TO 5018
5015 00 SLDC. PUSH #0000
5016 AB 03 SRO. BASE.03 := (TOS)
5018 EA SLDO. PUSH BASE.03
5019 00 SLDC. PUSH #0000
501A C4 GEQI. PUSH ((TOS-1) >= (TOS))
501B A1 04 UJP. IF NOT (TOS) THEN JUMP TO 5021
501D 01 SLDC. PUSH #0001
501E 91 NGI. PUSH -(TOS) (2'S COMP)
501F AB 03 SRO. BASE.03 := (TOS)
5021 EA SLDO. PUSH BASE.03
5022 00 SLDC. PUSH #0000
5023 C5 GRTI. PUSH ((TOS-1) > (TOS))
5024 A1 03 UJP. IF NOT (TOS) THEN JUMP TO 5029
5026 00 SLDC. PUSH #0000
5027 AB 03 SRO. BASE.03 := (TOS)
5029 EA SLDO. PUSH BASE.03
502A 00 SLDC. PUSH #0000
502B C8 LEQI. PUSH ((TOS-1) <= (TOS))
502C A1 03 UJP. IF NOT (TOS) THEN JUMP TO 5031
502E 01 SLDC. PUSH #0001
502F AB 03 SRO. BASE.03 := (TOS)
5031 EA SLDO. PUSH BASE.03
5032 00 SLDC. PUSH #0000
5033 C9 LESI. PUSH ((TOS-1) < (TOS))
5034 A1 05 UJP. IF NOT (TOS) THEN JUMP TO 503B
5036 00 SLDC. PUSH #0000
5037 AB 03 SRO. BASE.03 := (TOS)
5039 B9 03 UJP. JUMP TO 503E
503B 01 SLDC. PUSH #0001
503C AB 03 SRO. BASE.03 := (TOS)
503E C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*$R-*)
PROGRAM CASE_STATEMENT;
VAR
I : INTEGER;
BEGIN
CASE I OF
0 : I := 1;
1 : I := 0;
2 : I := 3;
3 : I := 2;
END;
CASE I OF
0, 1 : I := 2;
2, 3 : I := 3;
4 : I := 0;
END;
END.
FILE: 38 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 2
PARAM SIZE: 4
EXIT AT: 504C
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 EA SLDO. PUSH BASE.03
5003 B9 14 UJP. JUMP TO 5019
5005 01 SLDC. PUSH #0001
5006 AB 03 SRO. BASE.03 := (TOS)
5008 B9 1E UJP. JUMP TO 5028
500A 00 SLDC. PUSH #0000
500B AB 03 SRO. BASE.03 := (TOS)
500D B9 19 UJP. JUMP TO 5028
500F 03 SLDC. PUSH #0003
5010 AB 03 SRO. BASE.03 := (TOS)
5012 B9 14 UJP. JUMP TO 5028
5014 02 SLDC. PUSH #0002
5015 AB 03 SRO. BASE.03 := (TOS)
5017 B9 0F UJP. JUMP TO 5028
5019 AC 00 00 03 00 B9 08 TABLE: 1B 00 18 00 15 00 12 00
XJP. W1,W2,W3,<TABLE>
5028 EA SLDO. PUSH BASE.03
5029 B9 0F UJP. JUMP TO 503A
502B 02 SLDC. PUSH #0002
502C AB 03 SRO. BASE.03 := (TOS)
502E B9 1C UJP. JUMP TO 504C
5030 03 SLDC. PUSH #0003
5031 AB 03 SRO. BASE.03 := (TOS)
5033 B9 17 UJP. JUMP TO 504C
5035 00 SLDC. PUSH #0000
5036 AB 03 SRO. BASE.03 := (TOS)
5038 B9 12 UJP. JUMP TO 504C
503A AC (00)00 00 04 00 B9 0A TABLE: 17 00 19 00 16 00 18 00 15 00
XJP. W1,W2,W3,<TABLE>
504C C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*$R-*)
PROGRAM CASE_STATEMENT; (* HYDE416 *)
VAR
I : INTEGER;
BEGIN
CASE I OF
0 : I := 1;
1 : I := 0;
2 : I := 3;
3 : I := 2;
END;
CASE I OF
0, 1 : I := 2;
2, 3 : I := 3;
4 : I := 0;
24 : I := -2;
END;
END.
FILE: 39 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 2
PARAM SIZE: 4
EXIT AT: 507A
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 EA SLDO. PUSH BASE.03
5003 B9 14 UJP. JUMP TO 5019
5005 01 SLDC. PUSH #0001
5006 AB 03 SRO. BASE.03 := (TOS)
5008 B9 1E UJP. JUMP TO 5028
500A 00 SLDC. PUSH #0000
500B AB 03 SRO. BASE.03 := (TOS)
500D B9 19 UJP. JUMP TO 5028
500F 03 SLDC. PUSH #0003
5010 AB 03 SRO. BASE.03 := (TOS)
5012 B9 14 UJP. JUMP TO 5028
5014 02 SLDC. PUSH #0002
5015 AB 03 SRO. BASE.03 := (TOS)
5017 B9 0F UJP. JUMP TO 5028
5019 AC 00 00 03 00 B9 08 TABLE: 1B 00 18 00 15 00 12 00
XJP. W1,W2,W3,<TABLE>
5028 EA SLDO. PUSH BASE.03
5029 B9 15 UJP. JUMP TO 5040
502B 02 SLDC. PUSH #0002
502C AB 03 SRO. BASE.03 := (TOS)
502E B9 4A UJP. JUMP TO 507A
5030 03 SLDC. PUSH #0003
5031 AB 03 SRO. BASE.03 := (TOS)
5033 B9 45 UJP. JUMP TO 507A
5035 00 SLDC. PUSH #0000
5036 AB 03 SRO. BASE.03 := (TOS)
5038 B9 40 UJP. JUMP TO 507A
503A 02 SLDC. PUSH #0002
503B 91 NGI. PUSH -(TOS) (2'S COMP)
503C AB 03 SRO. BASE.03 := (TOS)
503E B9 3A UJP. JUMP TO 507A
5040 AC (00)00 00 18 00 B9 32 TABLE: 1D 00 1F 00 1C 00 1E 00 1B 00 0C
00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00
24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 3E 00
XJP. W1,W2,W3,<TABLE>
507A C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*$R-*)
PROGRAM EXPRESSIONS; (* HYDE417 *)
VAR
I : INTEGER;
J : INTEGER;
K : INTEGER;
B : BOOLEAN;
C : BOOLEAN;
D : BOOLEAN;
BEGIN
I := 0;
J := I;
J := PRED(I);
J := SUCC(I);
K := I + J;
K := I - J;
K := I * J;
K := I DIV J;
K := I MOD J;
K := -I;
B := I=J;
B := I <> J;
B := I >= J;
B := I <= J;
B := I > J;
B := I < J;
B := I IN [0,1];
B := C AND D;
B := C OR D;
B := NOT C;
B := ODD(I);
I := ORD(B);
END.
FILE: 40 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 12
PARAM SIZE: 4
EXIT AT: 5067
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 00 SLDC. PUSH #0000
5003 AB 03 SRO. BASE.03 := (TOS)
5005 EA SLDO. PUSH BASE.03
5006 AB 04 SRO. BASE.04 := (TOS)
5008 EA SLDO. PUSH BASE.03
5009 01 SLDC. PUSH #0001
500A 95 SBI. PUSH ((TOS-1) - (TOS))
500B AB 04 SRO. BASE.04 := (TOS)
500D EA SLDO. PUSH BASE.03
500E 01 SLDC. PUSH #0001
500F 82 ADI. PUSH ((TOS) + (TOS-1))
5010 AB 04 SRO. BASE.04 := (TOS)
5012 EA SLDO. PUSH BASE.03
5013 EB SLDO. PUSH BASE.04
5014 82 ADI. PUSH ((TOS) + (TOS-1))
5015 AB 05 SRO. BASE.05 := (TOS)
5017 EA SLDO. PUSH BASE.03
5018 EB SLDO. PUSH BASE.04
5019 95 SBI. PUSH ((TOS-1) - (TOS))
501A AB 05 SRO. BASE.05 := (TOS)
501C EA SLDO. PUSH BASE.03
501D EB SLDO. PUSH BASE.04
501E 8F MPI. PUSH ((TOS-1) * (TOS))
501F AB 05 SRO. BASE.05 := (TOS)
5021 EA SLDO. PUSH BASE.03
5022 EB SLDO. PUSH BASE.04
5023 86 DVI. PUSH ((TOS-1) / (TOS))
5024 AB 05 SRO. BASE.05 := (TOS)
5026 EA SLDO. PUSH BASE.03
5027 EB SLDO. PUSH BASE.04
5028 8E MODI. PUSH ((TOS-1) MOD (TOS))
5029 AB 05 SRO. BASE.05 := (TOS)
502B EA SLDO. PUSH BASE.03
502C 91 NGI. PUSH -(TOS) (2'S COMP)
502D AB 05 SRO. BASE.05 := (TOS)
502F EA SLDO. PUSH BASE.03
5030 EB SLDO. PUSH BASE.04
5031 C3 EQUI. PUSH ((TOS-1) = (TOS))
5032 AB 06 SRO. BASE.06 := (TOS)
5034 EA SLDO. PUSH BASE.03
5035 EB SLDO. PUSH BASE.04
5036 CB NEQI. PUSH ((TOS-1) <> (TOS))
5037 AB 06 SRO. BASE.06 := (TOS)
5039 EA SLDO. PUSH BASE.03
503A EB SLDO. PUSH BASE.04
503B C4 GEQI. PUSH ((TOS-1) >= (TOS))
503C AB 06 SRO. BASE.06 := (TOS)
503E EA SLDO. PUSH BASE.03
503F EB SLDO. PUSH BASE.04
5040 C8 LEQI. PUSH ((TOS-1) <= (TOS))
5041 AB 06 SRO. BASE.06 := (TOS)
5043 EA SLDO. PUSH BASE.03
5044 EB SLDO. PUSH BASE.04
5045 C5 GRTI. PUSH ((TOS-1) > (TOS))
5046 AB 06 SRO. BASE.06 := (TOS)
5048 EA SLDO. PUSH BASE.03
5049 EB SLDO. PUSH BASE.04
504A C9 LESI. PUSH ((TOS-1) < (TOS))
504B AB 06 SRO. BASE.06 := (TOS)
504D EA SLDO. PUSH BASE.03
504E 03 SLDC. PUSH #0003
504F 01 SLDC. PUSH #0001
5050 8B INN. PUSH TRUE IF (TOS-1) IN SET (TOS)
5051 AB 06 SRO. BASE.06 := (TOS)
5053 EE SLDO. PUSH BASE.07
5054 EF SLDO. PUSH BASE.08
5055 84 LAND. PUSH ((TOS-1) AND (TOS))
5056 AB 06 SRO. BASE.06 := (TOS)
5058 EE SLDO. PUSH BASE.07
5059 EF SLDO. PUSH BASE.08
505A 8D LOR. PUSH ((TOS-1) OR (TOS))
505B AB 06 SRO. BASE.06 := (TOS)
505D EE SLDO. PUSH BASE.07
505E 93 LNOT. PUSH -(TOS) (1'S COMP)
505F AB 06 SRO. BASE.06 := (TOS)
5061 EA SLDO. PUSH BASE.03
5062 AB 06 SRO. BASE.06 := (TOS)
5064 ED SLDO. PUSH BASE.06
5065 AB 03 SRO. BASE.03 := (TOS)
5067 C1 00 RBP. RETURN FROM BASE PROCEDURE.
5069 00 SLDC. PUSH #0000
(*R-*)
PROGRAM EXPRESSIONS; (* HYDE418 *)
VAR
I : INTEGER;
J : INTEGER;
K : INTEGER;
R : REAL;
B : BOOLEAN;
BEGIN
I := 1;
J := 2;
K := (I+J) * (J-I) + J DIV I;
R := (I+J) / (I-R) + J/I;
B := (I=0) AND (J=1) OR (K >= 0);
END.
FILE: 41 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 12
PARAM SIZE: 4
EXIT AT: 5038
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 D7 NOP. NOP
5001 D7 NOP. NOP
5002 01 SLDC. PUSH #0001
5003 AB 03 SRO. BASE.03 := (TOS)
5005 02 SLDC. PUSH #0002
5006 AB 04 SRO. BASE.04 := (TOS)
5008 EA SLDO. PUSH BASE.03
5009 EB SLDO. PUSH BASE.04
500A 82 ADI. PUSH ((TOS) + (TOS-1))
500B EB SLDO. PUSH BASE.04
500C EA SLDO. PUSH BASE.03
500D 95 SBI. PUSH ((TOS-1) - (TOS))
500E 8F MPI. PUSH ((TOS-1) * (TOS))
500F EB SLDO. PUSH BASE.04
5010 EA SLDO. PUSH BASE.03
5011 86 DVI. PUSH ((TOS-1) / (TOS))
5012 82 ADI. PUSH ((TOS) + (TOS-1))
5013 AB 05 SRO. BASE.05 := (TOS)
5015 A5 06 LA0. PUSH #BASE.06
5017 EA SLDO. PUSH BASE.03
5018 EB SLDO. PUSH BASE.04
5019 82 ADI. PUSH ((TOS) + (TOS-1))
501A EA SLDO. PUSH BASE.03
501B A5 06 LA0. PUSH #BASE.06
501D BC 02 LDM. PUSH 02 WORDS USING (TOS)^
501F 89 FLO. PUSH ( REAL(TOS-1))
5020 96 SBR. PUSH ((TOS-1) - (TOS))
5021 89 FLO. PUSH ( REAL(TOS-1))
5022 87 DVR PUSH ((TOS-1) / (TOS))
5023 EB SLDO. PUSH BASE.04
5024 EA SLDO. PUSH BASE.03
5025 8A FLT. PUSH ( REAL(TOS) )
5026 89 FLO. PUSH ( REAL(TOS-1))
5027 87 DVR PUSH ((TOS-1) / (TOS))
5028 83 ADR. PUSH ((TOS) + (TOS-1))
5029 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
502B EA SLDO. PUSH BASE.03
502C 00 SLDC. PUSH #0000
502D C3 EQUI. PUSH ((TOS-1) = (TOS))
502E EB SLDO. PUSH BASE.04
502F 01 SLDC. PUSH #0001
5030 C3 EQUI. PUSH ((TOS-1) = (TOS))
5031 84 LAND. PUSH ((TOS-1) AND (TOS))
5032 EC SLDO. PUSH BASE.05
5033 00 SLDC. PUSH #0000
5034 C4 GEQI. PUSH ((TOS-1) >= (TOS))
5035 8D LOR. PUSH ((TOS-1) OR (TOS))
5036 AB 08 SRO. BASE.08 := (TOS)
5038 C1 00 RBP. RETURN FROM BASE PROCEDURE.
(*R-*)
PROGRAM BUILTINS; (* HYDE419 *)
VAR
B : PACKED ARRAY[ 0..7] OF CHAR;
S : STRING;
I : INTEGER;
BEGIN
S := 'HELLO';
I := LENGTH(S);
I := POS( 'HE',S);
S := CONCAT(S, ' THERE');
S := COPY( S, 1, 5);
DELETE( S, 1, 2);
INSERT( 'HE', S, 1);
STR( I,S);
END.
FILE: 42 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 180
PARAM SIZE: 4
EXIT AT: 5071
ENTER AT: 5000
PROC NUMBER: 1
LEXICAL LEVEL: 0
5000 B9 74 UJP. JUMP TO 5076
5002 A5 07 LA0. PUSH #BASE.07
5004 D7 NOP. NOP
5005 A6 05 48 45 4C 4C 4F
HELLO
LSA. PUSH #(PC+1) POINTER TO THE STRING
500C AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
500E A5 07 LA0. PUSH #BASE.07
5010 00 SLDC. PUSH #0000
5011 BE LDB. PUSH #00, PUSH (TOS-1)^.TOS BYTE
5012 AB 30 SRO. BASE.30 := (TOS)
5014 D7 NOP. NOP
5015 A6 02 48 45
HE
LSA. PUSH #(PC+1) POINTER TO THE STRING
5019 A5 07 LA0. PUSH #BASE.07
501B 00 SLDC. PUSH #0000
501C 00 SLDC. PUSH #0000
501D CD 00 1B CXP. CALL EXTERNAL PROCEDURE: 1B IN SEGMENT: 00
5020 AB 30 SRO. BASE.30 := (TOS)
5022 A5 07 LA0. PUSH #BASE.07
5024 00 SLDC. PUSH #0000
5025 AB 31 SRO. BASE.31 := (TOS)
5027 A5 31 LA0. PUSH #BASE.31
5029 A5 07 LA0. PUSH #BASE.07
502B 50 SLDC. PUSH #0050
502C CD 00 17 CXP. CALL EXTERNAL PROCEDURE: 17 IN SEGMENT: 00
502F A5 31 LA0. PUSH #BASE.31
5031 A6 06 20 54 48 45 52 45
THERE
LSA. PUSH #(PC+1) POINTER TO THE STRING
5039 D7 NOP. NOP
503A 56 SLDC. PUSH #0056
503B CD 00 17 CXP. CALL EXTERNAL PROCEDURE: 17 IN SEGMENT: 00
503E A5 31 LA0. PUSH #BASE.31
5040 AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
5042 A5 07 LA0. PUSH #BASE.07
5044 A5 07 LA0. PUSH #BASE.07
5046 A5 31 LA0. PUSH #BASE.31
5048 01 SLDC. PUSH #0001
5049 05 SLDC. PUSH #0005
504A CD 00 19 CXP. CALL EXTERNAL PROCEDURE: 19 IN SEGMENT: 00
504D A5 31 LA0. PUSH #BASE.31
504F AA 50 SAS. TOS=CHAR::(TOS-1)^ := TOS CHAR
TOS=PTR ::(TOS-1)^ := (TOS)^ 50 CHARACTERS MAX
5051 A5 07 LA0. PUSH #BASE.07
5053 01 SLDC. PUSH #0001
5054 02 SLDC. PUSH #0002
5055 CD 00 1A CXP. CALL EXTERNAL PROCEDURE: 1A IN SEGMENT: 00
5058 D7 NOP. NOP
5059 A6 02 48 45
HE
LSA. PUSH #(PC+1) POINTER TO THE STRING
505D A5 07 LA0. PUSH #BASE.07
505F 50 SLDC. PUSH #0050
5060 01 SLDC. PUSH #0001
5061 CD 00 18 CXP. CALL EXTERNAL PROCEDURE: 18 IN SEGMENT: 00
5064 A9 30 LDO. PUSH BASE.30
5066 12 SLDC. PUSH #0012
5067 CD 1E 04 CXP. CALL EXTERNAL PROCEDURE: 04 IN SEGMENT: 1E
506A A5 07 LA0. PUSH #BASE.07
506C 50 SLDC. PUSH #0050
506D 0C SLDC. PUSH #000C
506E CD 1E 04 CXP. CALL EXTERNAL PROCEDURE: 04 IN SEGMENT: 1E
5071 1E SLDC. PUSH #001E
5072 9E 16 DUSE. DEC USE CNT FOR SEG #(TOS)
5074 B9 05 UJP. JUMP TO 507B
5076 1E SLDC. PUSH #001E
5077 9E 15 RSEG. READ SEGMENT #(TOS) FROM ACTIVE SEG TABLE
5079 B9 F6 UJP. JUMP TO 5002
507B C1 00 RBP. RETURN FROM BASE PROCEDURE.
507D 00 SLDC. PUSH #0000
507E 7C SLDC. PUSH #007C
507F 00 SLDC. PUSH #0000
(*$R-*)
PROGRAM CALLS_AND_PROCS; (* HYDE420 *)
PROCEDURE A;
BEGIN
END;
PROCEDURE B;
PROCEDURE C;
BEGIN
END;
BEGIN
B; (* RECURSIVE *)
C; (* CALL CHILD *)
A; (* CALL AT SAME LEVEL *)
END;
BEGIN
A;
B;
END.
FILE: 43 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 0
PARAM SIZE: 4
EXIT AT: 5030
ENTER AT: 502A
PROC NUMBER: 1
LEXICAL LEVEL: 0
502A D7 NOP. NOP
502B D7 NOP. NOP
502C CE 02 CLP. CALL CHILD PROCEDURE: 02
502E CE 03 CLP. CALL CHILD PROCEDURE: 03
5030 C1 00 RBP. RETURN FROM BASE PROCEDURE.
FILE: 43 SEG: 0 PROC: 2
JTAB FOR SUBROUTINE 2:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 5000
ENTER AT: 5000
PROC NUMBER: 2
LEXICAL LEVEL: 1
5000 AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 43 SEG: 0 PROC: 3
JTAB FOR SUBROUTINE 3:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 501E
ENTER AT: 5018
PROC NUMBER: 3
LEXICAL LEVEL: 1
5018 CF 03 CGP. CALL GLOBAL PROCEDURE: 03
501A CE 04 CLP. CALL CHILD PROCEDURE: 04
501C CF 02 CGP. CALL GLOBAL PROCEDURE: 02
501E AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 43 SEG: 0 PROC: 4
JTAB FOR SUBROUTINE 4:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 500C
ENTER AT: 500C
PROC NUMBER: 4
LEXICAL LEVEL: 2
500C AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
(*$R-*)
PROGRAM CALLS_AND_PROCS; (* HYDE421 *)
SEGMENT PROCEDURE B;
PROCEDURE C;
BEGIN
END;
BEGIN
END;
PROCEDURE A;
BEGIN
END;
PROCEDURE D;
PROCEDURE E;
BEGIN
END;
BEGIN
E;
D;
A;
END;
BEGIN
A;
B;
END.
FILE: 44 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 0
PARAM SIZE: 4
EXIT AT: 5031
ENTER AT: 502A
PROC NUMBER: 1
LEXICAL LEVEL: 0
502A D7 NOP. NOP
502B D7 NOP. NOP
502C CE 02 CLP. CALL CHILD PROCEDURE: 02
502E CD 07 01 CXP. CALL EXTERNAL PROCEDURE: 01 IN SEGMENT: 07
5031 C1 00 RBP. RETURN FROM BASE PROCEDURE.
5033 00 SLDC. PUSH #0000
FILE: 44 SEG: 0 PROC: 2
JTAB FOR SUBROUTINE 2:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 5000
ENTER AT: 5000
PROC NUMBER: 2
LEXICAL LEVEL: 1
5000 AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 44 SEG: 0 PROC: 3
JTAB FOR SUBROUTINE 3:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 501E
ENTER AT: 5018
PROC NUMBER: 3
LEXICAL LEVEL: 1
5018 CE 04 CLP. CALL CHILD PROCEDURE: 04
501A CF 03 CGP. CALL GLOBAL PROCEDURE: 03
501C CF 02 CGP. CALL GLOBAL PROCEDURE: 02
501E AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 44 SEG: 0 PROC: 4
JTAB FOR SUBROUTINE 4:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 500C
ENTER AT: 500C
PROC NUMBER: 4
LEXICAL LEVEL: 2
500C AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 44 SEG: 1 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 500C
ENTER AT: 500C
PROC NUMBER: 1
LEXICAL LEVEL: 1
500C AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 44 SEG: 1 PROC: 2
JTAB FOR SUBROUTINE 2:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 5000
ENTER AT: 5000
PROC NUMBER: 2
LEXICAL LEVEL: 2
5000 AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
(*$R-*)
PROGRAM INVOKING_FUNCTIONS; (* HYDE422 *)
VAR
I : INTEGER;
FUNCTION II : INTEGER;
BEGIN
II := 0;
END;
BEGIN
I := II;
END.
FILE: 45 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 2
PARAM SIZE: 4
EXIT AT: 5018
ENTER AT: 5010
PROC NUMBER: 1
LEXICAL LEVEL: 0
5010 D7 NOP. NOP
5011 D7 NOP. NOP
5012 00 SLDC. PUSH #0000
5013 00 SLDC. PUSH #0000
5014 CE 02 CLP. CALL CHILD PROCEDURE: 02
5016 AB 03 SRO. BASE.03 := (TOS)
5018 C1 00 RBP. RETURN FROM BASE PROCEDURE.
FILE: 45 SEG: 0 PROC: 2
JTAB FOR SUBROUTINE 2:
DATA SIZE: 0
PARAM SIZE: 4
EXIT AT: 5003
ENTER AT: 5000
PROC NUMBER: 2
LEXICAL LEVEL: 1
5000 00 SLDC. PUSH #0000
5001 CC 01 STL. MP.01 := (TOS)
5003 AD 01 RNP. RETURN FROM NON-BASE PROCEDURE.
5005 00 SLDC. PUSH #0000
PROGRAM TEST_DISASSEMBLERS; (* HYDE423 *)
VAR
I, J : INTEGER;
B : BOOLEAN;
C : CHAR;
R : REAL;
S : SET OF 1..15;
P : PACKED ARRAY[ 0..15] OF BOOLEAN;
RS : PACKED RECORD
I : INTEGER;
B : BOOLEAN;
C : CHAR;
A : PACKED ARRAY[ 0..5] OF CHAR;
C2 : CHAR;
R : REAL;
END;
PROCEDURE TSTPROC;
BEGIN
END;
FUNCTION TSTFUNCT : INTEGER;
BEGIN
TSTFUNCT := 0;
END;
BEGIN
I := 0;
J := I;
B := FALSE;
C := 'A';
R := 1.1;
S := [ 1, 2, 3, 15];
R := I + J * 5.5 - (6.6 / I);
IF (R <= I) THEN
J := TRUNC(R);
WHILE (I < 10) DO
I := I + 1;
FOR J := 0 TO 100 DO
R := R + 0.01;
REPEAT
I := I - 1;
UNTIL I <= 0;
FOR I := 0 TO 15 DO
P[I] := FALSE;
RS.I := 0;
RS.B := TRUE;
RS.C := 'A';
RS.A[3] := RS.C;
RS.R := 1.1;
RS.C2 := RS.A[3];
TSTPROC;
I := TSTFUNCT;
END.
FILE: 46 SEG: 0 PROC: 1
JTAB FOR SUBROUTINE 1:
DATA SIZE: 34
PARAM SIZE: 4
EXIT AT: 50F7
ENTER AT: 501C
PROC NUMBER: 1
LEXICAL LEVEL: 0
501C D7 NOP. NOP
501D D7 NOP. NOP
501E 00 SLDC. PUSH #0000
501F AB 04 SRO. BASE.04 := (TOS)
5021 EB SLDO. PUSH BASE.04
5022 AB 03 SRO. BASE.03 := (TOS)
5024 00 SLDC. PUSH #0000
5025 AB 05 SRO. BASE.05 := (TOS)
5027 41 SLDC. PUSH #0041
5028 AB 06 SRO. BASE.06 := (TOS)
502A A5 07 LA0. PUSH #BASE.07
502C B3 02 8C 3F CD CC
LDC. PUSH 02 WORDS
5032 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5034 C7 F2 7F LDCI. PUSH #7FF2
5037 91 NGI. PUSH -(TOS) (2'S COMP)
5038 01 SLDC. PUSH #0001
5039 A0 01 ADJ. ADJ SET TO 01 WORDS
503B AB 09 SRO. BASE.09 := (TOS)
503D A5 07 LA0. PUSH #BASE.07
503F EB SLDO. PUSH BASE.04
5040 EA SLDO. PUSH BASE.03
5041 B3 02 (02)B0 40 00 00
LDC. PUSH 02 WORDS
5048 89 FLO. PUSH ( REAL(TOS-1))
5049 90 MPR. PUSH ((TOS) * (TOS))
504A 89 FLO. PUSH ( REAL(TOS-1))
504B 83 ADR. PUSH ((TOS) + (TOS-1))
504C B3 02 D3 40 33 33
LDC. PUSH 02 WORDS
5052 EB SLDO. PUSH BASE.04
5053 8A FLT. PUSH ( REAL(TOS) )
5054 87 DVR PUSH ((TOS-1) / (TOS))
5055 96 SBR. PUSH ((TOS-1) - (TOS))
5056 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5058 A5 07 LA0. PUSH #BASE.07
505A BC 02 LDM. PUSH 02 WORDS USING (TOS)^
505C EB SLDO. PUSH BASE.04
505D 8A FLT. PUSH ( REAL(TOS) )
505E B4 02 LEQ. PUSH ((TOS-1) <= (TOS))--REALS
5060 A1 08 UJP. IF NOT (TOS) THEN JUMP TO 506A
5062 A5 07 LA0. PUSH #BASE.07
5064 BC 02 LDM. PUSH 02 WORDS USING (TOS)^
5066 9E 17 RND. PUSH ROUND(TOS)
5068 AB 03 SRO. BASE.03 := (TOS)
506A EB SLDO. PUSH BASE.04
506B 0A SLDC. PUSH #000A
506C C9 LESI. PUSH ((TOS-1) < (TOS))
506D A1 07 UJP. IF NOT (TOS) THEN JUMP TO 5076
506F EB SLDO. PUSH BASE.04
5070 01 SLDC. PUSH #0001
5071 82 ADI. PUSH ((TOS) + (TOS-1))
5072 AB 04 SRO. BASE.04 := (TOS)
5074 B9 F6 UJP. JUMP TO 506A
5076 00 SLDC. PUSH #0000
5077 AB 03 SRO. BASE.03 := (TOS)
5079 64 SLDC. PUSH #0064
507A AB 13 SRO. BASE.13 := (TOS)
507C EA SLDO. PUSH BASE.03
507D A9 13 LDO. PUSH BASE.13
507F C8 LEQI. PUSH ((TOS-1) <= (TOS))
5080 A1 16 UJP. IF NOT (TOS) THEN JUMP TO 5098
5082 A5 07 LA0. PUSH #BASE.07
5084 A5 07 LA0. PUSH #BASE.07
5086 BC 02 LDM. PUSH 02 WORDS USING (TOS)^
5088 B3 02 23 3C 0A D7
LDC. PUSH 02 WORDS
508E 83 ADR. PUSH ((TOS) + (TOS-1))
508F BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
5091 EA SLDO. PUSH BASE.03
5092 01 SLDC. PUSH #0001
5093 82 ADI. PUSH ((TOS) + (TOS-1))
5094 AB 03 SRO. BASE.03 := (TOS)
5096 B9 F4 UJP. JUMP TO 507C
5098 EB SLDO. PUSH BASE.04
5099 01 SLDC. PUSH #0001
509A 95 SBI. PUSH ((TOS-1) - (TOS))
509B AB 04 SRO. BASE.04 := (TOS)
509D EB SLDO. PUSH BASE.04
509E 00 SLDC. PUSH #0000
509F C8 LEQI. PUSH ((TOS-1) <= (TOS))
50A0 A1 F2 UJP. IF NOT (TOS) THEN JUMP TO 5098
50A2 00 SLDC. PUSH #0000
50A3 AB 04 SRO. BASE.04 := (TOS)
50A5 0F SLDC. PUSH #000F
50A6 AB 13 SRO. BASE.13 := (TOS)
50A8 EB SLDO. PUSH BASE.04
50A9 A9 13 LDO. PUSH BASE.13
50AB C8 LEQI. PUSH ((TOS-1) <= (TOS))
50AC A1 12 UJP. IF NOT (TOS) THEN JUMP TO 50C0
50AE A5 0A LA0. PUSH #BASE.0A
50B0 EB SLDO. PUSH BASE.04
50B1 00 SLDC. PUSH #0000
50B2 0F SLDC. PUSH #000F
50B3 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
50B4 C0 10 01 IXP. INDEX PACKED ARRAY. USE TOS & TOS-1, UB1,
UB2. ???
50B7 00 SLDC. PUSH #0000
50B8 BB STP. (TOS-1)^FIELDPTR := TOS. (TOS)-1: RTBIT;#;^
50B9 EB SLDO. PUSH BASE.04
50BA 01 SLDC. PUSH #0001
50BB 82 ADI. PUSH ((TOS) + (TOS-1))
50BC AB 04 SRO. BASE.04 := (TOS)
50BE B9 F0 UJP. JUMP TO 50A8
50C0 00 SLDC. PUSH #0000
50C1 AB 0B SRO. BASE.0B := (TOS)
50C3 A5 0C LA0. PUSH #BASE.0C
50C5 01 SLDC. PUSH #0001
50C6 00 SLDC. PUSH #0000
50C7 01 SLDC. PUSH #0001
50C8 BB STP. (TOS-1)^FIELDPTR := TOS. (TOS)-1: RTBIT;#;^
50C9 A5 0C LA0. PUSH #BASE.0C
50CB 08 SLDC. PUSH #0008
50CC 08 SLDC. PUSH #0008
50CD 41 SLDC. PUSH #0041
50CE BB STP. (TOS-1)^FIELDPTR := TOS. (TOS)-1: RTBIT;#;^
50CF A5 0D LA0. PUSH #BASE.0D
50D1 03 SLDC. PUSH #0003
50D2 00 SLDC. PUSH #0000
50D3 05 SLDC. PUSH #0005
50D4 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
50D5 A5 0C LA0. PUSH #BASE.0C
50D7 08 SLDC. PUSH #0008
50D8 08 SLDC. PUSH #0008
50D9 BA LDP. PUSH FIELD. TOS: RTBIT;#;^
50DA BF STB. (TOS-2)^.(TOS-1) := TOS BYTE
50DB A5 11 LA0. PUSH #BASE.11
50DD B3 02 (02)8C 3F CD CC
LDC. PUSH 02 WORDS
50E4 BD 02 STM. (TOS-1)^ := (TOS)^ 02 WORDS
50E6 A5 0D LA0. PUSH #BASE.0D
50E8 03 SLDC. PUSH #0003
50E9 00 SLDC. PUSH #0000
50EA 05 SLDC. PUSH #0005
50EB 88 CHK. IF (TOS-1) <= (TOS-2) <= (TOS) THEN PUSH TOS-2
ELSE ERROR
50EC BE LDB. PUSH #00, PUSH (TOS-1)^.TOS BYTE
50ED AB 10 SRO. BASE.10 := (TOS)
50EF CE 02 CLP. CALL CHILD PROCEDURE: 02
50F1 00 SLDC. PUSH #0000
50F2 00 SLDC. PUSH #0000
50F3 CE 03 CLP. CALL CHILD PROCEDURE: 03
50F5 AB 04 SRO. BASE.04 := (TOS)
50F7 C1 00 RBP. RETURN FROM BASE PROCEDURE.
50F9 00 SLDC. PUSH #0000
50FA 52 SLDC. PUSH #0052
50FB 00 SLDC. PUSH #0000
50FC 64 SLDC. PUSH #0064
50FD 00 SLDC. PUSH #0000
50FE 82 ADI. PUSH ((TOS) + (TOS-1))
50FF 00 SLDC. PUSH #0000
5100 96 SBR. PUSH ((TOS-1) - (TOS))
5101 00 SLDC. PUSH #0000
FILE: 46 SEG: 0 PROC: 2
JTAB FOR SUBROUTINE 2:
DATA SIZE: 0
PARAM SIZE: 0
EXIT AT: 5000
ENTER AT: 5000
PROC NUMBER: 2
LEXICAL LEVEL: 1
5000 AD 00 RNP. RETURN FROM NON-BASE PROCEDURE.
FILE: 46 SEG: 0 PROC: 3
JTAB FOR SUBROUTINE 3:
DATA SIZE: 0
PARAM SIZE: 4
EXIT AT: 500F
ENTER AT: 500C
PROC NUMBER: 3
LEXICAL LEVEL: 1
500C 00 SLDC. PUSH #0000
500D CC 01 STL. MP.01 := (TOS)
500F AD 01 RNP. RETURN FROM NON-BASE PROCEDURE.
5011 00 SLDC. PUSH #0000
Enjoy,
Tommy