head     56.3;
access   paws bayes jws quist brad dew jwh;
symbols  ;
locks    ; strict;
comment  @# @;


56.3
date     93.01.27.13.38.02;  author jwh;  state Exp;
branches ;
next     56.2;

56.2
date     93.01.27.12.13.22;  author jwh;  state Exp;
branches ;
next     56.1;

56.1
date     91.11.05.09.43.44;  author jwh;  state Exp;
branches ;
next     55.1;

55.1
date     91.08.25.10.21.54;  author jwh;  state Exp;
branches ;
next     54.1;

54.1
date     91.03.18.15.25.53;  author jwh;  state Exp;
branches ;
next     53.1;

53.1
date     91.03.11.19.27.05;  author jwh;  state Exp;
branches ;
next     52.1;

52.1
date     91.02.19.09.11.02;  author jwh;  state Exp;
branches ;
next     51.1;

51.1
date     91.01.30.16.10.36;  author jwh;  state Exp;
branches ;
next     50.1;

50.1
date     90.10.29.16.25.27;  author jwh;  state Exp;
branches ;
next     49.1;

49.1
date     90.08.14.14.09.45;  author jwh;  state Exp;
branches ;
next     48.1;

48.1
date     90.07.26.11.15.49;  author jwh;  state Exp;
branches ;
next     47.1;

47.1
date     90.05.14.10.57.51;  author dew;  state Exp;
branches ;
next     46.1;

46.1
date     90.05.07.08.45.00;  author jwh;  state Exp;
branches ;
next     45.1;

45.1
date     90.04.19.15.52.41;  author jwh;  state Exp;
branches ;
next     44.1;

44.1
date     90.04.01.22.10.04;  author jwh;  state Exp;
branches ;
next     43.1;

43.1
date     90.03.20.14.01.28;  author jwh;  state Exp;
branches ;
next     42.1;

42.1
date     90.01.23.17.46.06;  author jwh;  state Exp;
branches ;
next     41.6;

41.6
date     89.12.27.12.41.14;  author jwh;  state Exp;
branches ;
next     41.5;

41.5
date     89.12.26.16.55.21;  author jwh;  state Exp;
branches ;
next     41.4;

41.4
date     89.12.26.16.37.28;  author jwh;  state Exp;
branches ;
next     41.3;

41.3
date     89.12.26.14.48.37;  author jwh;  state Exp;
branches ;
next     41.2;

41.2
date     89.12.26.10.13.55;  author jwh;  state Exp;
branches ;
next     41.1;

41.1
date     89.12.22.11.28.50;  author jwh;  state Exp;
branches ;
next     40.1;

40.1
date     89.09.29.11.50.50;  author jwh;  state Exp;
branches ;
next     39.1;

39.1
date     89.09.26.16.35.11;  author dew;  state Exp;
branches ;
next     38.1;

38.1
date     89.08.29.11.26.54;  author jwh;  state Exp;
branches ;
next     37.1;

37.1
date     89.05.12.11.39.25;  author dew;  state Exp;
branches ;
next     36.1;

36.1
date     89.02.06.10.17.55;  author dew;  state Exp;
branches ;
next     35.1;

35.1
date     89.02.02.13.32.04;  author dew;  state Exp;
branches ;
next     34.1;

34.1
date     89.01.23.16.07.17;  author jwh;  state Exp;
branches ;
next     33.1;

33.1
date     89.01.16.11.39.54;  author dew;  state Exp;
branches ;
next     32.1;

32.1
date     89.01.10.11.47.49;  author bayes;  state Exp;
branches ;
next     31.1;

31.1
date     88.12.14.18.09.01;  author bayes;  state Exp;
branches ;
next     30.1;

30.1
date     88.12.09.13.46.20;  author dew;  state Exp;
branches ;
next     29.1;

29.1
date     88.10.31.15.30.59;  author bayes;  state Exp;
branches ;
next     28.1;

28.1
date     88.10.06.10.58.29;  author dew;  state Exp;
branches ;
next     27.1;

27.1
date     88.09.29.11.30.17;  author bayes;  state Exp;
branches ;
next     26.1;

26.1
date     88.09.28.13.11.25;  author bayes;  state Exp;
branches ;
next     25.1;

25.1
date     88.03.02.09.27.43;  author bayes;  state Exp;
branches ;
next     24.1;

24.1
date     87.08.31.09.47.30;  author jws;  state Exp;
branches ;
next     23.1;

23.1
date     87.08.26.10.24.37;  author bayes;  state Exp;
branches ;
next     22.1;

22.1
date     87.08.17.11.10.23;  author bayes;  state Exp;
branches ;
next     21.1;

21.1
date     87.08.12.13.53.06;  author bayes;  state Exp;
branches ;
next     20.1;

20.1
date     87.07.30.11.06.34;  author bayes;  state Exp;
branches ;
next     19.1;

19.1
date     87.06.01.08.22.19;  author jws;  state Exp;
branches ;
next     18.1;

18.1
date     87.05.20.15.20.34;  author bayes;  state Exp;
branches ;
next     17.1;

17.1
date     87.04.30.10.32.50;  author jws;  state Exp;
branches ;
next     16.1;

16.1
date     87.04.26.15.45.25;  author jws;  state Exp;
branches ;
next     15.1;

15.1
date     87.04.13.09.19.45;  author jws;  state Exp;
branches ;
next     14.2;

14.2
date     87.04.07.16.44.56;  author larry;  state Exp;
branches ;
next     14.1;

14.1
date     87.04.01.15.24.18;  author jws;  state Exp;
branches ;
next     13.1;

13.1
date     87.02.28.18.31.00;  author jws;  state Exp;
branches ;
next     12.1;

12.1
date     87.02.02.13.21.37;  author jws;  state Exp;
branches ;
next     11.1;

11.1
date     87.01.19.09.47.50;  author jws;  state Exp;
branches ;
next     10.1;

10.1
date     86.12.24.10.55.26;  author jws;  state Exp;
branches ;
next     9.1;

9.1
date     86.12.12.14.35.46;  author bayes;  state Exp;
branches ;
next     8.2;

8.2
date     86.12.09.11.11.32;  author jws;  state Exp;
branches ;
next     8.1;

8.1
date     86.11.27.11.53.34;  author jws;  state Exp;
branches ;
next     7.2;

7.2
date     86.11.25.14.37.55;  author jws;  state Exp;
branches ;
next     7.1;

7.1
date     86.11.20.13.43.06;  author hal;  state Exp;
branches ;
next     6.1;

6.1
date     86.11.04.17.55.19;  author paws;  state Exp;
branches ;
next     5.1;

5.1
date     86.10.28.16.44.53;  author hal;  state Exp;
branches ;
next     4.1;

4.1
date     86.09.30.19.44.14;  author hal;  state Exp;
branches ;
next     3.1;

3.1
date     86.09.01.11.55.01;  author hal;  state Exp;
branches ;
next     2.1;

2.1
date     86.07.30.14.41.06;  author hal;  state Exp;
branches ;
next     1.1;

1.1
date     86.06.30.14.55.15;  author danm;  state tmp;
branches ;
next     ;


desc
@Base file for PWS 3.2 release.

@


56.3
log
@
pws2rcs automatic delta on Wed Jan 27 13:14:25 MST 1993
@
text
@					       (*

 (c) Copyright Hewlett-Packard Company, 1985.
All rights are reserved.  Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.


	    RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the Government
is subject to restrictions as set forth in
paragraph (b) (3) (B) of the Rights in Technical
Data and Computer Software clause in
DAR 7-104.9(a).

HEWLETT-PACKARD COMPANY
Fort Collins, Colorado                         *)

$SYSPROG$ $DEBUG OFF$
$RANGE ON , PARTIAL_EVAL, OVFLCHECK OFF,STACKCHECK OFF$
$COPYRIGHT '(C) 1985 HEWLETT-PACKARD CO. 3.1'$
MODULE REVASM_MOD;
{ This module is used by the debugger for X format execution }
IMPORT ASM;
EXPORT
  PROCEDURE REVASM(ANYVAR INSP:INTEGER; VAR S:STRING;
		   ANYVAR NXTP,FTYPE:INTEGER);
implement
  PROCEDURE REVASM(ANYVAR INSP:INTEGER; VAR S:STRING;
		   ANYVAR NXTP,FTYPE:INTEGER);
  CONST
    MAXOPS = 34;
  TYPE
    UWORD = 0..65535;
    BYTE  = 0..255;
    IWORDA = PACKED ARRAY [1..MAXOPS] OF UWORD;
    INAMEA = ARRAY[1..MAXOPS] OF STRING[13];
    IBYTEA = PACKED ARRAY [1..MAXOPS] OF BYTE;
    REGBITS = PACKED ARRAY[0..15] OF BOOLEAN;
    WORD = -32768..32767;
    SBYTE = -128..127;
    HEXD  = 0..15;
    STRING1 = STRING[1];
    INSTREC = PACKED RECORD
	      CASE INTEGER OF
	      0 :(BYTE0 : BYTE;
		  BYTE1 : SBYTE);
	      1: (OPCODE : 0..15;
		  IREG2   : 0..7;
		  IMODE2  : 0..7;
		  IMODE1  : 0..7;
		  IREG1   : 0..7);
	      2: (IWORD  : UWORD);
	      3: (HEX0   : HEXD;  { OPCODE }
		  HEX1   : HEXD;
		  HEX2   : HEXD;
		  HEX3   : HEXD);
	      4: (BIT15  : BOOLEAN;
		  BIT14  : BOOLEAN;
		  BIT13  : BOOLEAN;
		  BIT12  : BOOLEAN;
		  BIT11  : BOOLEAN;
		  BIT10  : BOOLEAN;
		  BIT9   : BOOLEAN;
		  BIT8   : BOOLEAN;
		  BIT7   : BOOLEAN;
		  BIT6   : BOOLEAN;
		  BIT5   : BOOLEAN;
		  BIT4   : BOOLEAN;
		  BIT3   : BOOLEAN;
		  BIT2   : BOOLEAN;
		  BIT1   : BOOLEAN;
		  BIT0   : BOOLEAN);
	      5: (DUM1   : HEXD;
		  DATA   : 0..7;
		  BITX8  : BOOLEAN;
		  OPSIZE : 0..3;
		  fpredicate : 0..63);
	      6: (DUM2   : HEXD;
		  DUM3   : 0..7;
		  OPSIZE1: 0..3);
	      END;

     EAXREC = PACKED RECORD
	      CASE INTEGER OF
	      1:(EXOFFWORD : WORD);
	      2:(EXOFFLONG : INTEGER);
	      3:(EXB0      : BYTE;
		 EXB1      : BYTE);
	      4:(EXDABIT   : BOOLEAN;
		 EXREG     : 0..7;
		 EXWLBIT   : BOOLEAN;
		 exscale   : 0..3;
		 case fullindex : boolean of
		   false: (exoffbyte : -128..127);
		   true:  (exbs : boolean;
			   exis : boolean;
			   exbdsize : 0..3;
			   expadbit : boolean;
			   exindirect : 0..7));
	      5:(expad1 : hexd;
		 exDo : boolean;
		 exoffset : 0..31;
		 exDw : boolean;
		 exwidth : 0..31);
	      6:(expad2 : 0..127;
		 exDu : 0..7;
		 expad3 : 0..7;
		 exDc : 0..7);
	      7:(fopclas : 0..7;
		 frx : 0..7;
		 fry : 0..7;
		 case integer of
		   0: (fextension : 0..127);
		   1 :(fext : 0..15;
		       sincosreg : 0..7);
		   2: (Kfactor : -64..63);
		   3: (KDreg : 0..7;
		       zeros : 0..15));
	      END;
    EAXRECP = ^EAXREC;
    INSTRP  = ^INSTREC;
    OUTSTR  = STRING[80];

  CONST
    BRATYPE = 'RASRHILSCCCSNEEQVCVSPLMIGELTGTLE';
    CCTYPE  = 'T F HILSCCCSNEEQVCVSPLMIGELTGTLE';
    BITTYPE = 'BTSTBCHGBCLRBSET';
    SSIZE   = 'BWL@@';
    SRTYPE  = 'AS**LS**ROX*RO**';
    OPBITS = IWORDA[ HEX('1000'),HEX('2040'),HEX('2000'),HEX('3040'),
		     HEX('3000'),HEX('6000'),HEX('4E80'),HEX('4EC0'),
		     HEX('4E75'),HEX('4E70'),HEX('4E71'),HEX('4E72'),
		     HEX('4E73'),HEX('4E76'),HEX('4E77'),HEX('7000'),
		     HEX('4E58'),HEX('4880'),HEX('48C0'),HEX('4840'),
		     HEX('4E68'),HEX('4E74')
		     ,HEX('0000'),HEX('4000'),HEX('5000'),HEX('8000'),
		     HEX('9000'),HEX('B000'),HEX('C000'),HEX('D000'),
		     HEX('E000')
		     ,HEX('A000'),HEX('F000'),HEX('0000')];
    OPMASKS= IWORDA[ HEX('F000'),HEX('F1C0'),HEX('F000'),HEX('F1C0'),
		     HEX('F000'),HEX('F000'),HEX('FFC0'),HEX('FFC0'),
		     HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),
		     HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),HEX('F100'),
		     HEX('FFF8'),HEX('FFF8'),HEX('FFF8'),HEX('FFF8'),
		     HEX('FFF8'),HEX('FFFF')
		     ,HEX('F000'),HEX('F000'),HEX('F000'),HEX('F000'),
		     HEX('F000'),HEX('F000'),HEX('F000'),HEX('F000'),
		     HEX('F000')
		     ,HEX('F000'),HEX('F000'),HEX('0000')];
    OPNAMES= INAMEA['MOVE.B ','MOVEA.L ','MOVE.L ','MOVEA.W ',
		    'MOVE.W ','BRA','JSR ','JMP ',
		    'RTS','RESET','NOP','STOP # ',
		    'RTE','TRAPV','RTR','MOVEQ # ',
		    'UNLK A','EXT.W D','EXT.L D','SWAP D',
		    'MOVE USP,A','RTD # '
		    ,'0...','4...','5...','8...',
		    '9...','B...','C...','D...',
		    'E...'
		    ,'A...','F...','DC.W '];
    OPCTRL = IWORDA[2,1,1,1,
		    1,6,3,3,
		    0,0,0,4,
		    0,0,0,7,
		    5,5,5,5,
		    5,4
		    ,8,9,10,11,
		    12,13,14,15,
		    16,
		    65535,23,65535];

  VAR
    EAX   : EAXRECP;
    saveeax : EAXRECP;
    eaxplus2 : EAXRECP;
    original_eax : eaxrecp;
    INSR  : RECORD
	      CASE INTEGER OF
	      0:(INSTP:INSTRP);
	      1:(INSTI:INTEGER);
	    END;
    I,J,K : INTEGER;
    MODE1,REG1,MODE2,REG2 : INTEGER;
    OPC,OSIZE   : INTEGER;
    DONE  : BOOLEAN;

    FUNCTION SREG(I:INTEGER):STRING1;
    BEGIN SREG := ' '; SREG[1] := CHR(I+ORD('0'));
    END;

    PROCEDURE APPENDREG(RT:INTEGER; RN:INTEGER);
    CONST REGNAME='D A FP ';
    BEGIN
      S:=S+STR(REGNAME,RT*2+1,2);
      if rt = 2 { Float reg } then setstrlen(s,strlen(s)+1);
      S[STRLEN(S)]:=CHR(RN+ORD('0'));
    END;
    PROCEDURE COMMA;
    BEGIN S:=S+',';END;
    PROCEDURE NUMBERSIGN;
    BEGIN S:=S+'#';END;
    PROCEDURE BLANK;
    BEGIN S:=S+' ';END;
    PROCEDURE SUFFIX(N:INTEGER);
    CONST SUF='.B .W .L ';
    BEGIN S:=S+STR(SUF,N*3+1,3);END;
    PROCEDURE M7R1CHECK;
    BEGIN IF (MODE1=7) AND (REG1>1) THEN ESCAPE(0);
    END;
    PROCEDURE M7R4CHECK;
    BEGIN IF (MODE1=7) AND (REG1>4) THEN ESCAPE(0);
    END;
    PROCEDURE M1M7R1CHECK;
    BEGIN M7R1CHECK; IF (MODE1=1) THEN ESCAPE(0);
    END;
    PROCEDURE M1M7R4CHECK;
    BEGIN M7R4CHECK; IF (MODE1=1) THEN ESCAPE(0);
    END;

    procedure m1m3m4check;
      begin
      if (mode1=1) or (mode1=3) or (mode1=4) then
	escape(0);
      end;

    procedure m1m3m4m7r1check;
      begin
      m1m3m4check;
      m7r1check;
      end;

    procedure m1m3m4m7r4check;
      begin
      m1m3m4check;
      if (mode1=7) and (reg1=4) then
	escape(0);
      end;

    procedure bfreg; {additional Dreg for bit field ops}
      begin
      strwrite(s,strlen(s)+1,i,'D',saveeax^.exreg:1);
      end;

    procedure offset_width;
      begin
      with saveeax^ do
	begin
	s := s + '{';
	if exDo then
	  strwrite(s,strlen(s)+1,i,'D',exoffset:1)
	else
	  strwrite(s,strlen(s)+1,i,exoffset:1);
	s := s + ':';
	if exDw then
	  strwrite(s,strlen(s)+1,i,'D',exwidth:1,'}')
	else
	  if exwidth = 0 then
	    s := s + '32}'
	  else
	    strwrite(s,strlen(s)+1,i,exwidth:1,'}');
	end;
      end;

    PROCEDURE XREG(VAR XP:EAXREC);
    BEGIN APPENDREG(ORD(XP.EXDABIT),XP.EXREG);
    END;

    PROCEDURE CREG(VAR XP:EAXREC);
    BEGIN
      IF (XP.EXscale<>0) or (xp.fullindex) THEN ESCAPE(0);
      IF XP.EXWLBIT THEN
	IF XP.EXB1=0 THEN S:=S+'USP'
	ELSE if xp.exb1 = 1 then s := s + 'VBR'
	else if xp.exb1 = 2 then s := s + 'CAAR'
	else if xp.exb1 = 3 then s := s + 'MSP'
	else if xp.exb1 = 4 then s := s + 'ISP'
	else if xp.exb1 = 5 then s := s + 'MMUSR' { JWH 12/23/89 }
	else if xp.exb1 = 6 then s := s + 'URP' { JWH 12/23/89 }
	else if xp.exb1 = 7 then s := s + 'SRP' { JWH 12/23/89 }
	else escape(0)
      ELSE
	IF XP.EXB1=0 THEN S:=S+'SFC'
	ELSE if xp.exb1 = 1 then S:=S+'DFC'
	else if xp.exb1 = 2 then s := s + 'CACR'
	else if xp.exb1 = 3 then s := s + 'TC' { JWH 12/23/89 }
	else if xp.exb1 = 4 then s := s + 'ITT0' { JWH 12/23/89 }
	else if xp.exb1 = 5 then s := s + 'ITT1' { JWH 12/23/89 }
	else if xp.exb1 = 6 then s := s + 'DTT0' { JWH 12/23/89 }
	else if xp.exb1 = 7 then s := s + 'DTT1' { JWH 12/23/89 }
	else escape(0);
    END;

    PROCEDURE APPEND_INT(I:INTEGER);
    VAR P:INTEGER;
    BEGIN STRWRITE(S,STRLEN(S)+1,P,I:1);
    END;

    PROCEDURE DUMPEA(MODE,REG:INTEGER; VAR X:EAXRECP; SIZE : INTEGER);
    VAR
      I,D,L : INTEGER;
      savex : eaxrecp;
    BEGIN
      L:=0;
      CASE MODE OF
      0,1: APPENDREG(MODE,REG);
      2: S := S + '(A' + SREG(REG) + ')';
      3: S := S + '(A' + SREG(REG) + ')+';
      4: S := S + '-(A' + SREG(REG) + ')';
      5: BEGIN  { 16 BIT DISPLACEMENT + A REGISTER }
	   STRWRITE(S,STRLEN(S)+1,I,X^.EXOFFWORD:1,'(A',REG:1,')'); L:=2;
	 END;
      6: if not x^.fullindex then
	   if x^.exscale = 0 then
	     BEGIN  { 8 BIT DISPLACEMENT+A REGISTER+INDEX REGISTER }
	     STRWRITE(S,STRLEN(S)+1,I,X^.EXOFFBYTE:1,'(A',REG:1,',');
	     APPENDREG(ORD(X^.EXDABIT),X^.EXREG);
	     SUFFIX(ORD(X^.EXWLBIT)+1); S[STRLEN(S)]:=')'; L:=2;
	     END
	   else
	     begin
	     strwrite(s,strlen(s)+1,i,'(',x^.exoffbyte:1,',A',reg:1,',');
	     appendreg(ord(x^.exdabit),x^.exreg);
	     suffix(ord(x^.exwlbit)+1);
	     setstrlen(s,strlen(s)-1);          { suffix added extra blank }
	     case x^.exscale of
	       1: s := s + '*2)';
	       2: s := s + '*4)';
	       3: s := s + '*8)';
	     end;
	     l := 2;
	     end
	 else
	   begin
	   if x^.exindirect <> 0 then
	     s := s + '(['
	   else
	     s := s + '(';
	   savex := x;
	   x := addr(x^,2);
	   case savex^.exbdsize of
	     1: ;
	     2: begin
		strwrite(s,strlen(s)+1,i,x^.exoffword:1);
		x := addr(x^,2);
		end;
	     3: begin
		strwrite(s,strlen(s)+1,i,x^.exofflong:1);
		x := addr(x^,4);
		end;
	   end;
	   if not savex^.exbs then
	     begin
	     if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
	       comma;
	     strwrite(s,strlen(s)+1,i,'A',reg:1);
	     end;
	   if savex^.exindirect in [5,6,7] then
	     s := s + ']';
	   if not savex^.exis then
	     begin
	     if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
	       comma;
	     appendreg(ord(savex^.exdabit),savex^.exreg);
	     suffix(ord(savex^.exwlbit)+1);
	     setstrlen(s,strlen(s)-1);          { suffix added extra blank }
	     case savex^.exscale of
	       0: ;
	       1: s := s + '*2';
	       2: s := s + '*4';
	       3: s := s + '*8';
	     end;
	     end;
	   if savex^.exindirect in [1,2,3] then
	     s := s + ']';
	   case savex^.exindirect of
	     0,1,5: l := 0;
	     2,6  : begin
		    if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
		      comma;
		    strwrite(s,strlen(s)+1,i,x^.exoffword:1);
		    l := 2;
		    end;
	     3,7  : begin
		    if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
		      comma;
		    strwrite(s,strlen(s)+1,i,x^.exofflong:1);
		    l := 4;
		    end;
	     4: escape(0);
	   end;
	   s := s + ')';
	   end;
      7: CASE REG OF
	 0: BEGIN { SHORT ABSOLUTE } APPEND_INT(X^.EXOFFWORD); L:=2;
	    END;
	 1: BEGIN { LONG ABSOLUTE } APPEND_INT(X^.EXOFFLONG); L:=4;
	    END;
	 2: BEGIN       { PC + DISPLACEMENT }
	      D := ORD(ADDR(X^))-INSR.INSTI+X^.EXOFFWORD;
	      IF D<0 THEN S := S + '*' ELSE S := S + '*+';
	      APPEND_INT(D); L:=2;
	    END;
	 3: if not x^.fullindex then
	      if x^.exscale = 0 then
		BEGIN       { PC + INDEX REG }
		D := ORD(ADDR(X^))-INSR.INSTI+X^.EXOFFBYTE;
		IF D<0 THEN S := S + '*' ELSE S := S + '*+';
		STRWRITE(S,STRLEN(S)+1,I,D:1,'(');
		APPENDREG(ORD(X^.EXDABIT),X^.EXREG);
		SUFFIX(ORD(X^.EXWLBIT)+1); S[STRLEN(S)]:=')'; L:=2;
		END
	      else
		begin
		if x^.exoffbyte = 0 then
		  strwrite(s,strlen(s)+1,i,'(0,PC,')
		else
		  strwrite(s,strlen(s)+1,i,'(',x^.exoffbyte:1,',PC,');
		appendreg(ord(x^.exdabit),x^.exreg);
		suffix(ord(x^.exwlbit)+1);
		setstrlen(s,strlen(s)-1);          { suffix added extra blank }
		case x^.exscale of
		  1: s := s + '*2)';
		  2: s := s + '*4)';
		  3: s := s + '*8)';
		end;
		l := 2;
		end
	    else
	      begin
	      if x^.exindirect <> 0 then
		s := s + '(['
	      else
		s := s + '(';
	      savex := x;
	      x := addr(x^,2);
	      case savex^.exbdsize of
		1: ;
		2: begin
		   if x^.exoffword = 0 then
		     s := s + '0'
		   else
		     strwrite(s,strlen(s)+1,i,ORD(ADDR(X^))-2-INSR.INSTI+x^.exoffword:1);
		   x := addr(x^,2);
		   end;
		3: begin
		   if x^.exofflong = 0 then
		     s := s + '0'
		   else
		     strwrite(s,strlen(s)+1,i,ORD(ADDR(X^))-2-INSR.INSTI+x^.exofflong:1);
		   x := addr(x^,4);
		   end;
	      end;
	      if (s[strlen(s)] <> '(' ) and (s[strlen(s)] <> '[') then
		comma;
	      if not savex^.exbs then
		s := s + 'PC'
	      else
		s := s + 'ZPC';
	      if savex^.exindirect in [5,6,7] then
		s := s + ']';
	      if not savex^.exis then
		begin
		if (s[strlen(s)] <> '(' ) and (s[strlen(s)] <> '[') then
		  comma;
		appendreg(ord(savex^.exdabit),savex^.exreg);
		suffix(ord(savex^.exwlbit)+1);
		setstrlen(s,strlen(s)-1);          { suffix added extra blank }
		case savex^.exscale of
		  0: ;
		  1: s := s + '*2';
		  2: s := s + '*4';
		  3: s := s + '*8';
		end;
		end;
	      if savex^.exindirect in [1,2,3] then
		s := s + ']';
	      case savex^.exindirect of
		0,1,5: l := 0;
		2,6  : begin
		       if x^.exoffword = 0 then
			 s := s + ',0'
		       else
			 strwrite(s,strlen(s)+1,i,',',x^.exoffword:1);
		       l := 2;
		       end;
		3,7  : begin
		       if x^.exofflong = 0 then
			 s := s + ',0'
		       else
			  strwrite(s,strlen(s)+1,i,',',x^.exofflong:1);
		       l := 4;
		       end;
	      end;
	      s := s + ')';
	      end;
	 4: BEGIN       { IMMEDIATE }
	      NUMBERSIGN;
	      CASE SIZE OF
	      0: BEGIN APPEND_INT(X^.EXOFFBYTE); L:=2;
		 END;
	      1: BEGIN APPEND_INT(X^.EXOFFWORD); L:=2;
		 END;
	      2,3: BEGIN APPEND_INT(X^.EXOFFLONG); L:=4;
		 END;
	      OTHERWISE
	      END;      { CASE SIZE }
	    END;        { REG 4 }
	 OTHERWISE
	 END;   { CASE REG }
      END;      { CASE MODE }
      X := ADDR(X^,L);
    END;        { DUMPEA }

    PROCEDURE DUMPREGBITS(ANYVAR REGLIST : REGBITS;ZFIRST : BOOLEAN);
    VAR
      REGNUM,BITNUM     : INTEGER;
      REGCHAR   : STRING[1];
      LASTREG   : INTEGER;
      NEWLIST,INLIST,DONE       : BOOLEAN;
    BEGIN
      NEWLIST := FALSE; INLIST := FALSE; DONE := FALSE;
      LASTREG := 99;    REGNUM := 0;    REGCHAR := 'D';
      IF ZFIRST THEN BITNUM := 0 ELSE BITNUM := 15;

      REPEAT
	IF REGLIST[BITNUM] THEN
	BEGIN
	  IF REGNUM<>LASTREG+1 THEN
	  BEGIN
	    IF INLIST THEN
	    BEGIN
	      S := S +'-'+REGCHAR+SREG(LASTREG);
	      INLIST := FALSE; NEWLIST := TRUE;
	    END;
	    IF NEWLIST THEN S := S + '/';
	    S := S+REGCHAR+SREG(REGNUM);
	    INLIST := FALSE; NEWLIST := TRUE;
	  END
	  ELSE
	  BEGIN INLIST := TRUE; NEWLIST := FALSE; END;
	  LASTREG := REGNUM;
	END;
	REGNUM := REGNUM + 1;
	IF ZFIRST THEN BITNUM := BITNUM + 1
		  ELSE BITNUM := BITNUM - 1;
	IF REGNUM>7 THEN
	BEGIN
	  IF INLIST THEN S := S + '-'+REGCHAR+SREG(LASTREG);
	  IF REGCHAR='D' THEN
	  BEGIN
	    NEWLIST := LASTREG<>99;     INLIST := FALSE;
	    REGCHAR := 'A'; REGNUM := 0; LASTREG := 99;
	  END
	  ELSE DONE:=TRUE;
	END;
      UNTIL DONE;
    END;

  procedure dumpfea(mode,reg: integer; var x: eaxrecp; size: integer);
    type
      hexarray = array[0..15] of char;
    const
      hex = hexarray['0','1','2','3','4','5','6','7','8','9',
		     'A','B','C','D','E','F'];
    var
      j,l : integer;
      variantrec : packed record case integer of
		     0: (i: integer);
		     1: (h: packed array[1..24] of 0..15);
		     2: (i1,i2,i3: integer);
		   end;
    begin
    if (mode = 7) and (reg = 4) then { Immediate }
      begin
      s := s + '#';
      case size of
	0: {L} BEGIN APPEND_INT(X^.EXOFFLONG); L:=4; END;
	1: {S} begin
	       variantrec.i := x^.exofflong;
	       s := s + '$';
	       for j := 1 to 8 do
		 strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
	       l := 4;
	       end;
	2,3: {X,P} begin
		   variantrec.i1 := x^.exofflong;
		   x := addr(x^,4);
		   variantrec.i2 := x^.exofflong;
		   x := addr(x^,4);
		   variantrec.i3 := x^.exofflong;
		   s := s + '$';
		   for j := 1 to 24 do
		     strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
		   l := 4;
		   end;
	4: {W} BEGIN APPEND_INT(X^.EXOFFWORD); L:=2; END;
	5: {D} begin
	       variantrec.i1 := x^.exofflong;
	       x := addr(x^,4);
	       variantrec.i2 := x^.exofflong;
	       s := s + '$';
	       for j := 1 to 16 do
		 strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
	       l := 4;
	       end;
	6: {B} BEGIN APPEND_INT(X^.EXOFFBYTE); L:=2; END;
	otherwise escape(0);
      end; {case}
      eax := addr(eax^,l);
      end
    else
      dumpea(mode,reg,x,size);
    end;

  procedure dumpfregbits(reglist : byte; zfirst : boolean);
    type
      string1 = string[1];
    var
      variantrec : packed record case boolean of
		     true: (b: byte);
		     false:(a: packed array[0..7] of boolean);
		   end;
      regnum, bitnum, lastbit : integer;

    function makestring(c: char): string1;
      var
	s: string1;
      begin
      setstrlen(s,1);
      s[1] := c;
      makestring := s;
      end;

    procedure hithit; forward;

    procedure hitmiss; forward;

    procedure hithithit;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then
	  hithithit
	else
	  begin
	  s := s + 'FP' + makestring(chr(ord('0')+regnum-1));
	  hitmiss;
	  end
      else
	s := s + 'FP' + makestring(chr(ord('0')+regnum-1));
      end;

    procedure misshit;
      begin
      s := s + '/FP' + makestring(chr(ord('0')+regnum));
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then hithit
				else hitmiss;
      end;

    procedure hitmiss;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then misshit
				else hitmiss;
      end;

    procedure hithit;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if (bitnum = lastbit) then
	begin
	s := s + '-FP' + makestring(chr(ord('0')+regnum-1));
	end
      else if not variantrec.a[bitnum] then
	begin
	s := s + '-FP' + makestring(chr(ord('0')+regnum-1));
	hitmiss;
	end
      else
	begin
	s := s + '-';
	hithithit;
	end;
      end;

    procedure firsthit;
      begin
      s := s + 'FP' + makestring(chr(ord('0')+regnum));
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then hithit
				else hitmiss;
      end;

    procedure firstmiss;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then firsthit
				else firstmiss;
      end;

    begin
    variantrec.b := reglist;
    if zfirst then
      begin
      bitnum := 0;
      lastbit := 8;
      end
    else
      begin
      bitnum := 7;
      lastbit := -1;
      end;
    regnum := 0;
    if variantrec.a[bitnum] then firsthit
			    else firstmiss;
    end;

  procedure appendfloatsize(size : integer);
    begin
    case size of
      0: s := s + '.L ';
      1: s := s + '.S ';
      2: s := s + '.X ';
      3,7: s := s + '.P ';
      4: s := s + '.W ';
      5: s := s + '.D ';
      6: s := s + '.B ';
      otherwise escape(0);
    end; {case}
    end;

  procedure appendfloatcondition(predicate : integer);
    begin
    case predicate of
      0:  s := s + 'F';
      1:  s := s + 'EQ';
      2:  s := s + 'OGT';
      3:  s := s + 'OGE';
      4:  s := s + 'OLT';
      5:  s := s + 'OLE';
      6:  s := s + 'OGL';
      7:  s := s + 'OR';
      8:  s := s + 'UN';
      9:  s := s + 'UEQ';
      10: s := s + 'UGT';
      11: s := s + 'UGE';
      12: s := s + 'ULT';
      13: s := s + 'ULE';
      14: s := s + 'NEQ';
      15: s := s + 'T';
      16: s := s + 'SF';
      17: s := s + 'SEQ';
      18: s := s + 'GT';
      19: s := s + 'GE';
      20: s := s + 'LT';
      21: s := s + 'LE';
      22: s := s + 'GL';
      23: s := s + 'LEG';
      24: s := s + 'NLEG';
      25: s := s + 'NGL';
      26: s := s + 'NLE';
      27: s := s + 'NLT';
      28: s := s + 'NGE';
      29: s := s + 'NGT';
      30: s := s + 'SNE';       {LAF 870407 to match manual}
      31: s := s + 'ST';
      otherwise escape(0);
    end;
    end;

  procedure mc68881;
    begin
    if mode2 = 0 then
      if eax^.fopclas >= 6 then { FMOVEM }
	begin
	s := 'FMOVEM ';
	if eax^.fopclas = 6 then { move to FP data registers }
	  begin
	  saveeax := eax;
	  eax := addr(eax^,2);
	  if (mode1 = 0) or (mode1 = 1) or (mode1 = 4) or
	     ((mode1 = 7) and (reg1 = 4)) then { Dn, An, -(An), Imm }
	    escape(0);
	  dumpea(mode1,reg1,eax,0);
	  comma;
	  if saveeax^.frx = 6 then { D reg }
	    begin
	    if saveeax^.fry <> 0 then escape(0); { check for zero fields }
	    appendreg(0,saveeax^.KDreg);
	    if saveeax^.zeros <> 0 then escape(0); { zero fields ? }
	    end
	  else if saveeax^.frx = 4 then { register mask }
	    begin
	    if saveeax^.fry > 1 then escape(0); { check for zero fields }
	    dumpfregbits(saveeax^.exb1,true);
	    end
	  else escape(0);
	  end
	else { move from FP data registers }
	  begin
	  if (eax^.frx = 2) or (eax^.frx = 6) then
	    begin
	    if eax^.fry <> 0 then escape(0); { check for zero fields }
	    if eax^.frx = 2 then { only allow pre decr }
	      if mode1 <> 4 { -(An) } then escape(0);
	    if eax^.frx = 6 then { do not allow pre decr }
	      if mode1 = 4 { -(An) } then escape(0);
	    if eax^.zeros <> 0 then escape(0); { zero fields ? }
	    appendreg(0,eax^.KDreg);
	    end
	  else if (eax^.frx = 0) or (eax^.frx = 4) then
	    begin
	    if eax^.frx = 0 then { only allow pre decr }
	      if mode1 <> 4 { -(An) } then escape(0);
	    if eax^.frx = 4 then { do not allow pre decr }
	      if mode1 = 4 { -(An) } then escape(0);
	    if eax^.fry > 1 then escape(0); { check for zero fields }
	    if eax^.frx = 0 then dumpfregbits(eax^.exb1,false)
			    else dumpfregbits(eax^.exb1,true);
	    end
	  else escape(0);
	  comma;
	  eax := addr(eax^,2);
	  if (mode1 = 0) or (mode1 = 1) or (mode1 = 3) or
	     ((mode1 = 7) and (reg1 >= 2)) then {Dn, An, (An)+, PC modes, Imm}
	    escape(0);
	  dumpea(mode1,reg1,eax,0);
	  end;
	end
      else if eax^.fopclas >= 4 then { FMOVE sysreg }
	begin
	if eax^.frx in [1,2,4] then
	  s := 'FMOVE '
	else
	  s := 'FMOVEM ';
	if (eax^.fry <> 0) or (eax^.fextension <> 0) then escape(0);
	if eax^.fopclas = 4 then { move to sysregs }
	  begin
	  saveeax := eax;
	  eax := addr(eax^,2);
	  dumpea(mode1,reg1,eax,2);
	  case saveeax^.frx of
	    0: escape(0);
	    1: s := s + ',FPIADDR';
	    2: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + ',FPSTATUS';
	       end;
	    3: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm}
		 escape(0);
	       s := s + ',FPSTATUS/FPIADDR';
	       end;
	    4: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + ',FPCONTROL';
	       end;
	    5: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm}
		 escape(0);
	       s := s + ',FPCONTROL/FPIADDR';
	       end;
	    6: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm }
		 escape(0);
	       s := s + ',FPCONTROL/FPSTATUS';
	       end;
	    7: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm }
		 escape(0);
	       s := s + ',FPCONTROL/FPSTATUS/FPIADDR';
	       end;
	  end; {case}
	  end
	else { move from sysregs }
	  begin
	  if ((mode1 = 7) and (reg1 > 1)) then escape(0);
	  case eax^.frx of
	    0: escape(0);
	    1: s := s + 'FPIADDR,';
	    2: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + 'FPSTATUS,';
	       end;
	    3: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPSTATUS/FPIADDR,';
	       end;
	    4: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + 'FPCONTROL,';
	       end;
	    5: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPIADDR,';
	       end;
	    6: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPSTATUS,';
	       end;
	    7: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPSTATUS/FPIADDR,';
	       end;
	  end; {case}
	  eax := addr(eax^,2);
	  dumpea(mode1,reg1,eax,0);
	  end;
	end
      else if (eax^.fopclas = 2) and (eax^.frx = 7) then { FMOVECR }
	begin
	if (mode1 <> 0) or (reg1 <> 0) then escape(0);
	s := 'FMOVECR #';
	strwrite(s,strlen(s)+1,i,eax^.fextension:1,',');
	appendreg(2,eax^.fry);
	eax := addr(eax^,2);
	end
      else { general }
	begin
	case eax^.fextension of
	  0: s := 'FMOVE';
	  1: s := 'FINT';
	  2: s := 'FSINH';
	  3: s := 'FINTRZ';     (* LAF 861204 *)
	  4: s := 'FSQRT';
	  6: s := 'FLOGNP1';
	  8: s := 'FETOXM1';
	  9: s := 'FTANH';
	  10:s := 'FATAN';
	  12:s := 'FASIN';
	  13:s := 'FATANH';
	  14:s := 'FSIN';
	  15:s := 'FTAN';
	  16:s := 'FETOX';
	  17:s := 'FTWOTOX';
	  18:s := 'FTENTOX';
	  20:s := 'FLOGN';
	  21:s := 'FLOG10';
	  22:s := 'FLOG2';
	  24:s := 'FABS';
	  25:s := 'FCOSH';
	  26:s := 'FNEG';
	  28:s := 'FACOS';
	  29:s := 'FCOS';
	  30:s := 'FGETEXP';
	  31:s := 'FGETMAN';
	  32:s := 'FDIV';
	  33:s := 'FMOD';
	  34:s := 'FADD';
	  35:s := 'FMUL';
	  36:s := 'FSGLDIV';
	  37:s := 'FREM';
	  38:s := 'FSCALE';
	  39:s := 'FSGLMUL';
	  40:s := 'FSUB';
	  48..55:s := 'FSINCOS';
	  56:s := 'FCMP';
	  58:s := 'FTST';
	  64 : s := 'FSMOVE';   { JWH 12/23/89 }
	  65 : s := 'FSSQRT';   { JWH 12/23/89 }
	  68 : s := 'FDMOVE';   { JWH 12/23/89 }
	  69 : s := 'FDSQRT';   { JWH 12/23/89 }
	  88 : s := 'FSABS';   { JWH 12/23/89 }
	  90 : s := 'FSNEG';   { JWH 12/23/89 }
	  92 : s := 'FDABS';   { JWH 12/23/89 }
	  94 : s := 'FDNEG';   { JWH 12/23/89 }
	  96 : s := 'FSDIV';   { JWH 12/23/89 }
	  98 : s := 'FSADD';   { JWH 12/23/89 }
	  99 : s := 'FSMUL';   { JWH 12/23/89 }
	 100 : s := 'FDDIV';   { JWH 12/23/89 }
	 102 : s := 'FDADD';   { JWH 12/23/89 }
	 103 : s := 'FDMUL';   { JWH 12/23/89 }
	 104 : s := 'FSSUB';   { JWH 12/23/89 }
	 108 : s := 'FDSUB';   { JWH 12/23/89 }
	  otherwise ;
	end; {case}
	if eax^.fopclas = 0 then { source is Freg }
	  begin
	  if (mode1 <> 0) or (reg1 <> 0) then escape(0);
	  blank;
	  appendreg(2,eax^.frx);
	  if (eax^.fextension = 58 {FTST}) or ((eax^.frx = eax^.fry) and
	     (eax^.fextension <> 0 {FMOVE}) and (eax^.fextension < 32)) then
	    { Do not display second op for FTST or "single op" instructions }
	  else
	    begin
	    comma;
	    if eax^.fext = 6 then { FSINCOS }
	      begin
	      appendreg(2,eax^.sincosreg);
	      s := s + ':';
	      end;
	    appendreg(2,eax^.fry);
	    end;
	  eax := addr(eax^,2);
	  end
	else if eax^.fopclas = 2 then { source is <ea> }
	  begin
	  if mode1 = 1 then { An } escape(0);
	  if mode1 = 0 then { Dn }
	    if eax^.frx in [2,3,5] then { size - X,P,D } escape(0);
	  appendfloatsize(eax^.frx);
	  saveeax := eax;
	  eax := addr(eax^,2);
	  dumpfea(mode1,reg1,eax,saveeax^.frx);
	  if  saveeax^.fextension <> 58 {FTST} then
	    begin
	    comma;
	    if saveeax^.fext = 6 then { FSINCOS }
	      begin
	      appendreg(2,saveeax^.sincosreg);
	      s := s + ':';
	      end;
	    appendreg(2,saveeax^.fry);
	    end;
	  end
	else if eax^.fopclas = 3 then { dest is <ea> }
	  begin { FMOVE from MC68881 }
	  s := 'FMOVE';
	  appendfloatsize(eax^.frx);
	  appendreg(2,eax^.fry);
	  if mode1 = 0 {Dreg} then
	    if eax^.frx in [2,3,5,7] then escape(0);
	  if (mode1 = 1) or ((mode1 = 7) and (reg1 > 1)) then
	    escape(0);
	  saveeax := eax;
	  eax := addr(eax^,2);comma;
	  dumpea(mode1,reg1,eax,0);
	  if saveeax^.frx = 3 {size P} then
	    strwrite(s,strlen(s)+1,i,'{#',saveeax^.Kfactor:1,'}')
	  else if saveeax^.frx = 7 {size P} then
	    begin
	    if saveeax^.zeros <> 0 then escape(0);
	    strwrite(s,strlen(s)+1,i,'{D',saveeax^.KDreg:1,'}');
	    end;
	  end
	else escape(0);
	end
    else
      case mode2 of
	1: { FScc, FDBcc, FTRAPcc }
	   begin
	   if mode1 = 1 then
	     s := 'FDB'
	   else if (mode1 = 7) and (reg1 = 4) then
	     s := 'FTRAP'       (* LAF 861204 *)
	   else if (mode1 = 7) and ((reg1 = 2) or (reg1 = 3)) then
	     s := 'FTRAP'       (* LAF 861204 *)
	   else
	     s := 'FS';
	   appendfloatcondition(eax^.exb1);
	   eax := addr(eax^,2);
	   if mode1 = 1 then
	     begin
	     if s = 'FDBF' then
	       s := 'FDBRA '
	     else
		blank;
	     appendreg(0,reg1);
	     comma;
	     s := s + '*';
	     k := eax^.exoffword;
	     k := k +4; { avoid 16 bit math }
	     eax := addr(eax^,2);
	     if k >= 0 then s := s + '+';
	     strwrite(s,strlen(s)+1,i,k:1);
	     end
	   else if (mode1 = 7) and (reg1 = 4) then
	     { FTcc }
	   else if (mode1 = 7) and (reg1 = 2) then
	     begin { FTPcc.W }
	     s := s + '.W #';
	     strwrite(s,strlen(s)+1,i,eax^.exoffword:1);
	     eax := addr(eax^,2);
	     end
	   else if (mode1 = 7) and (reg1 = 3) then
	     begin { FTPcc.L }
	     s := s + '.L #';
	     strwrite(s,strlen(s)+1,i,eax^.exofflong:1);
	     eax := addr(eax^,4);
	     end
	   else
	     begin
	     blank;
	     if (mode1 = 1) or ((mode1 = 7) and (reg1 >= 2)) then
	       escape(0);  { An, PC modes, Imm }
	     dumpea(mode1,reg1,eax,1);
	     end;
	   end;
	2,3: { Revearse assemble FBF *+2 as FNOP }
	     if (insr.instp^.fpredicate = 0) and (mode2 = 2) and
		(eax^.exoffword = 0) then
	       begin { FNOP }
	       eax := addr(eax^,2);
	       s := 'FNOP';
	       end
	     else { FBcc }
	       begin
	       if insr.instp^.fpredicate = 15 {FBT} then
		 s := 'FBRA'
	       else
		 begin
		 s := 'FB';
		 appendfloatcondition(insr.instp^.fpredicate);
		 end;
	       if mode2 = 3 then
		 begin
		 s := s + '.L';
		 j := eax^.exofflong;
		 eax := addr(eax^,4);
		 end
	       else
		 begin
		 j := eax^.exoffword;
		 eax := addr(eax^,2);
		 end;
	       j := j + 2;
	       s := s + ' *';
	       if j >= 0 then s := s + '+';
	       strwrite(s,strlen(s)+1,i,j:1);
	       end;
	4,5: { FSAVE, FRESTORE }
	     begin
	     if mode2 = 4 then
	       begin
	       if (mode1 = 0) or (mode1 = 1) or (mode1 = 3) or
		  ((mode1 = 7) and (reg1 >= 2)) then {Dn, An, (An)+, Imm, PC}
		 escape(0);
	       s := 'FSAVE ';
	       end
	     else
	       begin
	       if (mode1 = 0) or (mode1 = 1) or (mode1 = 4) or
		  ((mode1 = 7) and (reg1 = 4)) then {Dn, An, -(An), Imm}
		 escape(0);
	       s := 'FRESTORE ';
	       end;
	     dumpea(mode1,reg1,eax,1);
	     end;
	otherwise escape(0);
      end {case};
    done := true;
    end; { mc68881 }

  { Added 12/24/89 JWH : }

  procedure move16; { Handle the '040 move16 instruction }
  type move16_type =
	packed record
	  case integer of
	    1: (the_op : byte;
		which : 0..7;
		mode_16 : 0..3;
		reg_ax : 0..7);
	    2: (w : UWORD);
	end; { move16_type }
    type my_word =
	packed record
	  case integer of
	1: (nib1,nib2 : 0..15;
	  byte_it : byte);
	2: (w : WORD);
       end; { my_word type }
    var see_it : move16_type;
    var see_ex : my_word;
    begin
      see_it.w := INSR.INSTP^.IWORD;  { see it as a move16 }
  { So far we've examined only the first 7 bits of the instruction }
      s := 'MOVE16 ';
      with see_it do
       begin
	if the_op <> hex('F6') { $F6 } then escape(0); { First 8 bits }
	if which > 1 then escape(0); { First 11 bits }
	if which = 1 then { have post increment format }
	 begin
	  if mode_16 <> 0 then { gotta be for this format }
	     escape(0); { First 13 bits }
	  if eax^.exDAbit <> TRUE { 1 }  then { gotta be for this format }
	     escape(0); { First 17 bits }
	  see_ex.w := eax^.exoffword;
	  if ((see_ex.nib2 <> 0) or (see_ex.byte_it <> 0)) then
	     escape(0); { All 32 bits checked out }
	  s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  s := s + '+'; { emitpostincr(reg_ax); }
	  comma;
	  s := s + '('; APPENDREG(1,EAX^.EXREG); s := s + ')';
	  s := s + '+';
	  { emitpostincr(ext.exRn1); }
	 end { which = 1 , post increment format }
	else  { which = 0, have absolute format }
	 begin
	   { All 48 bits fit the format at this point ... }
	   case mode_16 of
	    0 : begin s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      s := s + '+'; comma; DUMPEA(7,1,EAX,4); end;
	    1 : begin DUMPEA(7,1,EAX,4); comma;
		      s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      s := s + '+'; end;
	    2 : begin s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      comma; DUMPEA(7,1,EAX,4); end;
	    3 : begin DUMPEA(7,1,EAX,4); comma;
		      s := s + '('; APPENDREG(1,reg_ax); s := s + ')'; end;
	    otherwise ; { this really can't happen }
	   end; { case }
	 end; { which = 0, absolute format }
       end; { with see_it }
       done := TRUE;
     end; { move16 }

    { Added 12/24/89 JWH : }

  procedure cinv_cpush; { Handle '040 CINV and CPUSH instructions }
  type cache_40_type =
	packed record
	  case integer of
	    1: (the_op : byte;
		which_caches : 0..3;
		which_instr : 0..1;
		scope : 0..3;
		reg_ax : 0..7);
	    2: (w : UWORD);
	end; { cache_40_type }
    var see_it : cache_40_type;
    begin
     see_it.w := INSR.INSTP^.IWORD; { see it as a cinv or cpush }
  { So far we've examined only the first 7 bits of the instruction }
     with see_it do
      begin
       if the_op <> hex('F4') then escape(0); { First 8 bits }
       if which_instr = 0 then
	begin { CINV }
	 case scope of
	  0 : escape(0); { ILLEGAL }
	  1 : s := 'CINVL ';
	  2 : s := 'CINVP ';
	  3 : s := 'CINVA ';
	  otherwise ;
	 end; { case }
	 case which_caches of
	  0 : s := s + 'NONE'; { NOOP, NOT ILLEGAL }
	  1 : s := s + 'DC';
	  2 : s := s + 'IC';
	  3 : s := s + 'DC/IC';
	  otherwise ;
	 end; { case }
	 if ((scope = 1) or (scope = 2)) then { CINVL or CINVP .. }
	  begin { get the reg ... }
	    comma; s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  end; { CINVL or CINVP }
	end { CINV }
       else
	begin { CPUSH }
	 case scope of
	  0 : escape(0); { ILLEGAL }
	  1 : s := 'CPUSHL ';
	  2 : s := 'CPUSHP ';
	  3 : s := 'CPUSHA ';
	  otherwise ;
	 end; { case }
	 case which_caches of
	  0 : s := s + 'NONE';  { NOOP, NOT ILLEGAL }
	  1 : s := s + 'DC';
	  2 : s := s + 'IC';
	  3 : s := s + 'DC/IC';
	  otherwise ;
	 end; { case }
	 if ((scope = 1) or (scope = 2)) then { CPUSHL or CPUSHP .. }
	  begin { get the register ... }
	    comma; s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  end; { CPUSHL or CPUSHP }
	end; { CPUSH }
      end; { with see_it }
      done := TRUE;
    end; { cinv_cpush }

  {************************************************************}
  {************************************************************}
  BEGIN { REV ASM }
    INSR.INSTI:=INSP;
    EAX := ADDR(INSR.INSTP^,2);
    original_eax := eax;
    SETSTRLEN(S,0);
    WITH INSR.INSTP^ DO
    TRY
      MODE1:=IMODE1; MODE2:=IMODE2; REG1:=IREG1; REG2:=IREG2;
      I:=1; DONE := FALSE;
      WHILE IAND(IWORD,OPMASKS[I])<>OPBITS[I] DO I := I + 1;
      OPC :=OPCTRL[I]; S := OPNAMES[I]; OSIZE:=OPSIZE;
      REPEAT
      CASE OPC OF
      0:DONE:=TRUE; {NO OPERANDS}
      1:BEGIN   { MOVE.B .W .L }
	  M7R4CHECK;
	  IF MODE2=7 THEN IF REG2>1 THEN ESCAPE(0);
	  IF OPCODE=1 THEN
	    begin
	    if mode1 = 1 {An} then escape(0);
	    OSIZE:=0;
	    end
	  ELSE
	    IF OPCODE=2 THEN OSIZE:=2 ELSE OSIZE:=1;
	  DUMPEA(MODE1,REG1,EAX,OSIZE);
	  COMMA;
	  DUMPEA(MODE2,REG2,EAX,OSIZE);
	  DONE := TRUE;
	END;
      2:IF MODE2=1 THEN ESCAPE(0) ELSE OPC:=1;  { MOVE.B }
      3:BEGIN   {JMP OR JSR}
	  IF (MODE1=2) OR (MODE1>4) THEN
	  BEGIN IF (MODE1=7) AND (REG1>3) THEN ESCAPE(0); END
	  ELSE ESCAPE(0);
	  OPC:=19;
	END;
      4:BEGIN   { STOP, RTD }
	  STRWRITE(S,STRLEN(S),I,EAX^.EXOFFWORD:1);
	  EAX := ADDR(EAX^,2);
	  DONE := TRUE;
	END;
      5:BEGIN  { REG IS ONLY ARG }
	  S := S+SREG(REG1); DONE := TRUE;
	END;
      6:BEGIN   {Bcc, BRA, BSR}
	  J := HEX1 * 2 + 1;
	  S[2]:=BRATYPE[J]; S[3]:=BRATYPE[J+1];
	  if byte1 = -1 then {32 bit disp}
	    begin
	    j := eax^.exofflong;
	    eax := addr(eax^,4);
	    s := s + '.L';
	    end
	  else IF BYTE1<>0 THEN
	    BEGIN J := BYTE1; S := S + '.S'; END
	  ELSE
	    BEGIN J := EAX^.EXOFFWORD; EAX := ADDR(EAX^,2); END;
	  S := S + ' *';
	  IF J>=(-2) THEN S := S + '+';
	  if j = maxint then
	    s := s + '2147483649'
	  else if j = maxint-1 then
	    s := s + '2147483648'
	  else
	    STRWRITE(S,STRLEN(S)+1,I,J+2:1);
	  DONE := TRUE;
	END;
      7:BEGIN
	  STRWRITE(S,STRLEN(S),I,BYTE1:1,',D',REG2:1); DONE:=TRUE;
	END;
      8:BEGIN   { OPCODE 0 }
	  IF BIT8 AND (MODE1=1) THEN
	    BEGIN        { MOVEP }
	    S := 'MOVEP'; SUFFIX(ORD(BIT6)+1);


	    IF BIT7 THEN
	      BEGIN
	      APPENDREG(0,REG2); COMMA; APPEND_INT(EAX^.EXOFFWORD);
	      STRWRITE(S,STRLEN(S)+1,I,'(A',SREG(REG1),')');
	      END
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,EAX^.EXOFFWORD:1,
	       '(A',SREG(REG1),'),D',SREG(REG2));
	    EAX := ADDR(EAX^,2);       { SKIP THE OFFSET }
	    END          { MOVEP }
	  ELSE
	    BEGIN
	    IF BIT8 OR (REG2=4) THEN
	      BEGIN      { BTST, BCHG, BCLR, BSET }
	      if mode1 = 1 then escape(0);
	      if mode1 = 7 then
		if osize = 0 { BTST } then
		  begin
		  if not bit8 and (reg1 > 3) then escape(0);
		  end
		else if reg1 > 1 then escape(0);
	      S := STR(BITTYPE,OSIZE*4+1,4);
	      IF BIT8 THEN     { BIT # IS IN D REG }
		      BEGIN BLANK; APPENDREG(0,REG2); COMMA; END
	      ELSE
		BEGIN            { BIT # IS IMMEDIATE }
		K := EAX^.EXB1;
		IF MODE1=0 THEN K := K MOD 32 ELSE K := K MOD 8;
		BLANK; NUMBERSIGN; APPEND_INT(K); COMMA;
		EAX := ADDR(EAX^,2);
		END;
	      OPC:=19;
	      END        { BIT OPS }
	    ELSE if bit11 and (opsize=3) then { CAS, CAS2 }
	      if (mode1 = 7) and (reg1 = 4) then { CAS2 }
		begin
		eaxplus2 := addr(eax^,2);
		case reg2 of
		  5: s := 'CAS2.B';
		  6: s := 'CAS2.W';
		  7: s := 'CAS2.L';
		  otherwise escape(0);
		end;
		strwrite(s,strlen(s)+1,i,
			   ' D',eax^.exDc:1,':D',eaxplus2^.exDc:1,
			   ',D',eax^.exDu:1,':D',eaxplus2^.exDu:1,',(');
		if eax^.exdabit then s := s + 'A'
				else s := s + 'D';
		strwrite(s,strlen(s)+1,i,eax^.exreg:1,'):(');
		if eaxplus2^.exdabit then s := s + 'A'
				     else s := s + 'D';
		strwrite(s,strlen(s)+1,i,eaxplus2^.exreg:1,')');
		eax := addr(eax^,4);
		end
	      else { CAS }
		begin
		m1m7r1check;
		if mode1 = 0 {Dn} then escape(0);
		case reg2 of
		  5: s := 'CAS.B D';
		  6: s := 'CAS.W D';
		  7: s := 'CAS.L D';
		  otherwise escape(0);
		end;
		strwrite(s,strlen(s)+1,i,eax^.exDc:1,',','D',eax^.exDu:1,',');
		eax := addr(eax^,2);
		opc := 19;
		end
	    else if (opsize = 3) and (reg2 < 3) then {CHK2 CMP2}
	      begin
	      m1m3m4check;
	      if (mode1 = 0) or ((mode1 = 7) and (reg1 = 4)) then escape(0);
	      if eax^.exwlbit then s := 'CHK2'
			      else s := 'CMP2';
	      case reg2 of
		0: s := s + '.B ';
		1: s := s + '.W ';
		2: s := s + '.L ';
	      end;
	      saveeax := eax;
	      eax := addr(eax^,2);
	      DUMPEA(MODE1,REG1,EAX,0);
	      comma;
	      if saveeax^.exdabit then s := s + 'A'
				  else s := s + 'D';
	      strwrite(s,strlen(s)+1,i,saveeax^.exreg:1);
	      end
	    else
	      BEGIN
	      CASE HEX1 OF
	      0,2,10:
		 BEGIN { ORI, ANDI, EORI }
		 IF HEX1=0 THEN S := 'ORI'
		 ELSE
		   IF HEX1=2 THEN S := 'ANDI'
		   ELSE
		   IF HEX1=10 THEN S := 'EORI';

		 IF (MODE1=7) AND (REG1=4) THEN
		   BEGIN       { op to CCR or SR }
		   IF OSIZE>1 THEN ESCAPE(0);
		   BLANK;
		   IF HEX2=3 THEN
		     begin
		     dumpea(7,4,eax,0);
		     S := S + ',CCR';
		     end
		   ELSE
		     begin
		     dumpea(7,4,eax,1);
		     S := S + ',SR';
		     end;
		   END
		 ELSE
		   BEGIN
		   M1M7R1CHECK;
		   IF OSIZE=3 THEN ESCAPE(0);
		   S := S + '.' + STR(SSIZE,OSIZE+1,1); BLANK;
		   OPC:=20;
		   END;
		 END;
	      4,6: if opsize = 3 then { RTM, CALLM }
		     if mode1 <= 1 then { RTM }
		       begin
		       if mode1 = 0 then s := 'RTM D'
				    else s := 'RTM A';
		       strwrite(s,strlen(s)+1,i,reg1:1);
		       end
		     else { CALLM }
		       begin
		       m1m3m4m7r4check;
		       if (mode1 = 0) then escape(0);
		       s := 'CALLM #';
		       strwrite(s,strlen(s)+1,i,eax^.exb1:1);
		       comma;
		       eax := addr(eax^,2);
		       opc := 19;
		       end
		   else
		     BEGIN       { ADDI, SUBI }
		     M1M7R1CHECK;
		     IF OSIZE=3 THEN ESCAPE(0);
		     IF HEX1=4 THEN S := 'SUBI.' ELSE S := 'ADDI.';
		     S := S + STR(SSIZE,OSIZE+1,1); BLANK;
		     OPC:=20;
		     END;
	      12:BEGIN {CMPI}
		 if (mode1 = 1) or ((mode1 = 7) and (reg1 = 4)) then
		   escape(0);
		 IF OSIZE=3 THEN ESCAPE(0);
		 STRWRITE(S,1,I,'CMPI.',SSIZE[OSIZE+1]); BLANK;
		 OPC:=20;
		 END;
	      14:BEGIN {MOVES}
		 M7R1CHECK;
		 IF (MODE1<2) OR (OSIZE=3) THEN ESCAPE(0);
		 STRWRITE(S,1,I,'MOVES.',SSIZE[OSIZE+1]); BLANK;
		 I:=ORD(EAX^.EXDABIT); J:=ORD(EAX^.EXREG);
		 IF EAX^.EXWLBIT THEN
		   BEGIN
		   XREG(EAX^); COMMA; EAX:=ADDR(EAX^,2);
		   DUMPEA(MODE1,REG1,EAX,OSIZE);
		   END
		 ELSE
		   BEGIN
		   eax := addr(eax^,2);
		   DUMPEA(MODE1,REG1,EAX,OSIZE); COMMA; APPENDREG(I,J);
		   END;
		 END;
	      OTHERWISE ESCAPE(0)       { INVALID INSTRUCTION }
	      END;
	    END;
	  END;
	  DONE:=(OPC=8);
	END;
      9:BEGIN  { OPCODE 4 }
	  IF BIT8 THEN
	    BEGIN        { CHK, LEA, EXTB }
	    IF (OSIZE=2) or (osize = 0) THEN
	      BEGIN      { CHK }
	      IF MODE1=1 THEN ESCAPE(0);
	      if mode2 = 6 then
		begin
		S := 'CHK.W ';
		DUMPEA(MODE1,REG1,EAX,1);
		end
	      else if mode2 = 4 then
		begin
		s := 'CHK.L ';
		DUMPEA(MODE1,REG1,EAX,2);
		end
	      else escape(0);
	      COMMA; APPENDREG(0,REG2);
	      END
	    else if mode1 = 0 then { EXTB }
	      begin
	      s := 'EXTB.L ';
	      appendreg(0,reg1);
	      end
	    else if mode2 = 7 then
	      BEGIN      { LEA }
	      IF (MODE1<2) OR (MODE1=3) OR (MODE1=4) OR
		((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
		S := 'LEA ';
		DUMPEA(MODE1,REG1,EAX,2); COMMA; APPENDREG(1,REG2);
	      END
	    else escape(0);
	    END  { CHK , LEA }
	  ELSE
	  CASE HEX1 OF
	  0: BEGIN
	       M1M7R1CHECK;
	       IF OSIZE=3 THEN S := 'MOVE SR,'
			  ELSE S := 'NEGX.'+STR(SSIZE,OSIZE+1,1)+' ';
	       OPC:=18;
	     END;
	  2: BEGIN
	       M1M7R1CHECK;
	       IF OSIZE=3 THEN
	       BEGIN    { MOVE from CCR }
		 S:='MOVE CCR,';DUMPEA(MODE1,REG1,EAX,1);
	       END
	       ELSE
	       BEGIN    { CLR }
		 S := 'CLR.'+STR(SSIZE,OSIZE+1,1); BLANK; OPC:=18;
	       END;
	     END;
	  4: BEGIN
	       IF MODE1=1 THEN ESCAPE(0);
	       IF OSIZE=3 THEN
	       BEGIN   { MOVE TO CCR }
		 S := 'MOVE ';
		 DUMPEA(MODE1,REG1,EAX,1); S := S + ',CCR';
	       END
	       ELSE
	       BEGIN   { NEG }
		 M7R1CHECK;
		 S := 'NEG.'+STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=18;
	       END;
	     END;
	  6: BEGIN
	       IF MODE1=1 THEN ESCAPE(0);
	       IF OSIZE=3 THEN
	       BEGIN   { MOVE TO SR }
		 S := 'MOVE ';
		 DUMPEA(MODE1,REG1,EAX,1); S := S + ',SR';
	       END
	       ELSE
	       BEGIN   { NOT }
		 M7R1CHECK;
		 S := 'NOT.'+STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=18;
	       END;
	     END;
	  8: BEGIN
	     IF BIT7 THEN
	       BEGIN { MOVEM TO EA or EXT.W or EXT.L }
		 IF MODE1=0 THEN
		 BEGIN
		 s := 'EXT';
		 SUFFIX(ORD(BIT6)+1); BLANK; APPENDREG(0,REG1);
		 END
		 ELSE
		 BEGIN { MOVEM TO EA }
		   M7R1CHECK;
		   IF (MODE1<2) OR (MODE1=3) THEN ESCAPE(0);
		   S:='MOVEM'; SUFFIX(ORD(BIT6)+1);
		   DUMPREGBITS(EAX^,MODE1=4);
		   EAX := ADDR(EAX^,2); COMMA;
		   OPC:=19;
		 END;
	       END
	     ELSE if (hex2 = 0) and bit3 then {LINK.L}
	       begin
	       strwrite(s,1,i,'LINK.L A',reg1:1,',#',eax^.exofflong:1);
	       eax := addr(eax^,4);
	       end
	     else IF OSIZE=0 THEN
	       BEGIN { NBCD }
	       M1M7R1CHECK; S := 'NBCD '; OPC:=19;
	       END
	     ELSE if mode1 = 1 then {BKPT}
	       begin
	       s := 'BKPT #';
	       strwrite(s,strlen(s)+1,i,reg1:1);
	       end
	     else
	       BEGIN
	       IF MODE1=0 THEN S := 'SWAP D'+SREG(REG1)
	       ELSE
		 BEGIN { PEA }
		 IF (MODE1<2) OR (MODE1=3) OR (MODE1=4) OR
		    ((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
		 S := 'PEA '; DUMPEA(MODE1,REG1,EAX,2);
		 END;
	       END;
	     END;
	  10:if iword = hex('4AFC') then
	       s := 'ILLEGAL'
	     else
	       BEGIN     { TST, TAS }
		 if osize = 3 {TAS} then
		 M1M7R1CHECK;
		 if osize = 0 {TST.B} then
		   if mode1 = 1 then escape(0);
		 IF OSIZE=3 THEN S := 'TAS '
			    ELSE S := 'TST.' + STR(SSIZE,OSIZE+1,1) + ' ';
		 OPC:=19;
	       END;
	  12:if bit7 then
	       BEGIN     { MOVEM EA TO REGS }
	       IF (MODE1<2) OR (MODE1=4) OR
		  ((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
	       S:='MOVEM'; SUFFIX(ORD(BIT6)+1);
	       EAX := ADDR(EAX^,2);
	       DUMPEA(MODE1,REG1,EAX,2); COMMA;
	       INSR.INSTP := ADDR(INSR.INSTP^,2);
	       DUMPREGBITS(INSR.INSTP^,FALSE);
	       END
	     else if bit6 then {DIVS.L DIVU.L}
	       begin
	       m1m7r4check;
	       if eax^.exwlbit then s := 'DIVS'
			       else s := 'DIVU';
	       if eax^.exscale = 2 then s := s + '.L '
	       else if eax^.exreg = eax^.exoffbyte then
		 s := s + '.L '
	       else
		 s := s + 'L.L ';
	       saveeax := eax;
	       eax := addr(eax^,2);
	       dumpea(mode1,reg1,eax,2);
	       comma;
	       if (saveeax^.exreg <> saveeax^.exoffbyte) or
		  (saveeax^.exscale = 2) then
		 begin
		 appendreg(0,saveeax^.exoffbyte);
		 s := s + ':';
		 end;
	       appendreg(0,saveeax^.exreg);
	       end
	     else {MULS or MULU}
	       begin
	       m1m7r4check;
	       if eax^.exwlbit then s := 'MULS.L '
			       else s := 'MULU.L ';
	       saveeax := eax;
	       eax := addr(eax^,2);
	       dumpea(mode1,reg1,eax,2);
	       comma;
	       if saveeax^.exscale = 2 then
		 begin
		 appendreg(0,saveeax^.exoffbyte);
		 s := s + ':'
		 end;
	       appendreg(0,saveeax^.exreg);
	       end;
	  14:BEGIN
	       CASE HEX2 OF
	       4: STRWRITE(S,1,I,'TRAP #',HEX3:1);
	       5: BEGIN
		    IF BIT3 THEN STRWRITE(S,1,I,'UNLK A',REG1:1)
		    ELSE
		    BEGIN
		      STRWRITE(S,1,I,'LINK.W A',REG1:1,',#',EAX^.EXOFFWORD:1);
		      EAX := ADDR(EAX^,2);
		    END;
		  END;
	       6: BEGIN {MOVE USP,..  or MOVE ..,USP}
		    IF BIT3 THEN S := 'MOVE USP,A' + SREG(REG1)
			    ELSE S := 'MOVE A'+ SREG(REG1) + ',USP';
		  END;
	       7: BEGIN {MOVEC}
		    S:='MOVEC ';
		    IF HEX3=11 THEN BEGIN XREG(EAX^); COMMA; CREG(EAX^);
				    END
		    ELSE
		    IF HEX3=10 THEN BEGIN CREG(EAX^); COMMA; XREG(EAX^);
				    END
			       ELSE ESCAPE(0);
		    EAX:=ADDR(EAX^,2);
		  END;
		 OTHERWISE  ESCAPE(0)   { INVALID INSTRUCTION }
	       END;    { CASE HEX2 }
	     END;
	     OTHERWISE  ESCAPE(0)   { INVALID INSTRUCTION }
	  END; { CASE HEX1 }
	  DONE:=(OPC=9);
	END;   { OPCODE 4 }
     10:if (hex2 = 15) and bit3 and (reg1 in [2,3,4]) then { TRAPcc }
	  begin
	  case hex1 of
	    0: s := 'TRAPT';
	    1: s := 'TRAPF';
	    2: s := 'TRAPHI';
	    3: s := 'TRAPLS';
	    4: s := 'TRAPCC';
	    5: s := 'TRAPCS';
	    6: s := 'TRAPNE';
	    7: s := 'TRAPEQ';
	    8: s := 'TRAPVC';
	    9: s := 'TRAPVS';
	    10: s := 'TRAPPL';
	    11: s := 'TRAPMI';
	    12: s := 'TRAPGE';
	    13: s := 'TRAPLT';
	    14: s := 'TRAPGT';
	    15: s := 'TRAPLE';
	  end;
	  if reg1 = 2 then { .W }
	    begin
	    strwrite(s,strlen(s)+1,i,'.W #',eax^.exoffword:1);
	    eax := addr(eax^,2);
	    end
	  else if reg1 = 3 then { .L }
	    begin
	    strwrite(s,strlen(s)+1,i,'.L #',eax^.exofflong:1);
	    eax := addr(eax^,4);
	    end;
	  done := true;
	  end
	else
	  BEGIN  { ADDQ or SUBQ or Scc or DBcc }
	  IF OSIZE=3 THEN
	    BEGIN
	    J := HEX1 * 2 + 1;
	    IF MODE1=1 THEN
	      BEGIN
	      if j = 1 then
		STRWRITE(S,1,I,'DBT D',REG1:1,',*')
	      else if j = 3 then
		STRWRITE(S,1,I,'DBRA D',REG1:1,',*')
	      else
		STRWRITE(S,1,I,'DB',STR(CCTYPE,J,2),' D',REG1:1,',*');
	      K := EAX^.EXOFFWORD;
	      k := k +2; { avoid 16 bit math }
	      EAX := ADDR(EAX^,2);
	      IF K>=0 THEN S := S + '+';
	      STRWRITE(S,STRLEN(S)+1,I,K:1);
	      END
	    ELSE
	      BEGIN
	      M7R1CHECK; S:='S   ';
	      if j = 1 then
		s := 'ST '
	      else if j = 3 then
		s := 'SF '
	      else
		STRWRITE(S,2,I,STR(CCTYPE,J,2));
	      OPC:=19;
	      END;
	    END
	  ELSE
	    BEGIN
	    IF (MODE1=1) AND (OSIZE=0) THEN ESCAPE(0);
	    M7R1CHECK;
	    IF BIT8 THEN S := 'SUBQ.' ELSE S := 'ADDQ.';
	    J := DATA; IF J=0 THEN J:=8;
	    STRWRITE(S,STRLEN(S)+1,I,SSIZE[OSIZE+1],' #',J:1,',');
	    OPC:=18;
	    END;
	  DONE:=(OPC=10);
	  END;
     11:BEGIN { OR DIVU DIVS SBCD }
	IF (MODE2=3) OR (MODE2=7) THEN
	    BEGIN        { DIVU or DIVS }
	    M1M7R4CHECK;
	    IF MODE2=3 THEN S := 'DIVU.W ' ELSE S := 'DIVS.W ';
	    DUMPEA(MODE1,REG1,EAX,1); COMMA; APPENDREG(0,REG2);
	    END
	ELSE IF bit8 AND (MODE1<2) THEN
	  if mode2 = 4 then
	    BEGIN        { SBCD }
	    IF BIT3 THEN
	      STRWRITE(S,1,I,'SBCD -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,1,I,'SBCD D',REG1:1,',D',REG2:1)
	    END
	  else { PACK UNPK }
	    begin
	    if mode2 = 5 then s := 'PACK '
			 else s := 'UNPK ';
	    if mode1 = 0 then { D reg }
	      strwrite(s,strlen(s)+1,i,'D',reg1:1,',D',reg2:1,
						      ',#',eax^.exoffword:1)
	    else { -(A reg) }
	      strwrite(s,strlen(s)+1,i,'-(A',reg1:1,'),-(A',reg2:1,
						  '),#',eax^.exoffword:1);
	    eax := addr(eax^,2);
	    end
	ELSE
	  BEGIN        { OR }
	  S := 'OR.' + STR(SSIZE,OSIZE+1,1); BLANK;
	  IF BIT8 THEN
	    BEGIN M7R1CHECK; OPC:=22; END
	  ELSE
	    BEGIN M1M7R4CHECK; OPC:=21; END;
	  END;
	DONE:=(OPC=11);
	END;
     12:BEGIN  { SUB , SUBA or SUBX }
	  IF OSIZE=3 THEN
	  BEGIN
	    M7R4CHECK;
	    S:='SUBA'; SUFFIX(ORD(BIT8)+1);
	    DUMPEA(MODE1,REG1,EAX,OPSIZE1); COMMA; APPENDREG(1,REG2);
	  END
	  ELSE
	  IF BIT8 AND (MODE1<2) THEN
	  BEGIN        { SUBX }
	    S := 'SUBX.'+STR(SSIZE,OSIZE+1,1);
	    IF BIT3 THEN
	      STRWRITE(S,STRLEN(S)+1,I,' -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,' D',REG1:1,',D',REG2:1);
	  END
	  ELSE
	  BEGIN        { SUB }
	    S := 'SUB.'+STR(SSIZE,OSIZE+1,1); BLANK;
	    IF BIT8 THEN
	    BEGIN      { DESTINATION IS <EA> }
	      M7R1CHECK;
	      IF (MODE1<2) THEN ESCAPE(0);
	      OPC:=22;
	    END
	    ELSE
	    BEGIN
	      IF (OSIZE=0) AND (MODE1=1) THEN ESCAPE(0);
	      OPC:=21;
	    END;
	  END;
	  DONE:=(OPC=12);
	END;
     13:BEGIN { CMP ,CMPA, CMPM,  EOR }
	   IF OSIZE=3 THEN
	   BEGIN       { CMPA }
	     S := 'CMPA'; SUFFIX(ORD(BIT8)+1);
	     DUMPEA(MODE1,REG1,EAX,ORD(BIT8)+1); COMMA; APPENDREG(1,REG2);
	   END
	   ELSE
	   BEGIN
	     IF BIT8 THEN
	     BEGIN
	       IF MODE1=1 THEN
		 S := 'CMPM.' + STR(SSIZE,OSIZE+1,1) + ' (A' + SREG(REG1) +
			 ')+,(A' + SREG(REG2) + ')+'
	       ELSE
	       BEGIN { EOR }
		 M7R1CHECK;
		 S := 'EOR.' + STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=22;
	       END;
	     END
	     ELSE
	     BEGIN       { CMP }
	       IF (MODE1=1) AND (MODE2=0) THEN ESCAPE(0);
	       S := 'CMP.' + STR(SSIZE,MODE2+1,1); BLANK;
	       DUMPEA(MODE1,REG1,EAX,MODE2); COMMA; APPENDREG(0,REG2);
	     END;
	   END;
	   DONE:=(OPC=13);
	 END;
     14:BEGIN  { AND, MULU, MULS, ABCD }
	       { EXG                   }
	  IF (MODE2=3) OR (MODE2=7) THEN
	  BEGIN        { MULU or MULS }
	    M1M7R4CHECK;
	    IF MODE2=3 THEN S := 'MULU.W '
		       ELSE S := 'MULS.W ';
	    DUMPEA(MODE1,REG1,EAX,1); COMMA; APPENDREG(0,REG2);
	  END
	  ELSE
	  IF (MODE2=4) AND (MODE1<2) THEN
	  BEGIN        { ABCD }
	    IF BIT3 THEN
	      STRWRITE(S,1,I,'ABCD -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,1,I,'ABCD D',REG1:1,',D',REG2:1)
	  END
	  ELSE
	  IF (MODE2=6) AND (MODE1=1) THEN
	     STRWRITE(S,1,I,'EXG D',REG2:1,',A',REG1:1)
	  ELSE
	  IF (MODE2=5) AND (MODE1=0) THEN
	     STRWRITE(S,1,I,'EXG D',REG2:1,',D',REG1:1)
	  ELSE
	  IF (MODE2=5) AND (MODE1=1) THEN
	     STRWRITE(S,1,I,'EXG A',REG2:1,',A',REG1:1)
	  ELSE
	  BEGIN        { AND }
	   S := 'AND.' + STR(SSIZE,OSIZE+1,1); BLANK;
	   IF BIT8 THEN
	   BEGIN
	     M7R1CHECK;
	     IF (MODE1<2) THEN ESCAPE(0);
	     OPC:=22;
	   END
	   ELSE
	   BEGIN
	     M1M7R4CHECK; OPC:=21;
	   END;
	  END;
	  DONE:=(OPC=14);
	 END;
     15: BEGIN { ADD , ADDA or ADDX }
	  IF OSIZE=3 THEN
	  BEGIN
	    M7R4CHECK;
	    S := 'ADDA'; SUFFIX(ORD(BIT8)+1);
	    DUMPEA(MODE1,REG1,EAX,OPSIZE1); COMMA; APPENDREG(1,REG2);
	  END
	  ELSE
	  IF BIT8 AND (MODE1<2) THEN
	  BEGIN        { ADDX }
	    S := 'ADDX.'+STR(SSIZE,OSIZE+1,1);
	    IF BIT3 THEN
	      STRWRITE(S,STRLEN(S)+1,I,' -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,' D',REG1:1,',D',REG2:1);
	  END
	  ELSE
	  BEGIN      { ADD }
	    S := 'ADD.'+STR(SSIZE,OSIZE+1,1); BLANK;
	    IF BIT8 THEN
	    BEGIN    { DESTINATION IS <EA> }
	      M7R1CHECK;
	      IF (MODE1<2) THEN ESCAPE(0);
	      OPC:=22;
	    END
	    ELSE
	    BEGIN
	      IF (OSIZE=0) AND (MODE1=1) THEN ESCAPE(0);
	      OPC:=21;
	    END;
	  END;
	  DONE:=(OPC=15);
	 END;
      16:if bit11 and bit7 and bit6 then {bit field instr}
	   begin
	   case hex1 of
	     8: begin m1m3m4m7r4check; s := 'BFTST '; end;
	     9: begin m1m3m4m7r4check; s := 'BFEXTU '; end;
	     10: begin m1m3m4m7r1check; s := 'BFCHG '; end;
	     11: begin m1m3m4m7r4check; s := 'BFEXTS '; end;
	     12: begin m1m3m4m7r1check; s := 'BFCLR '; end;
	     13: begin m1m3m4m7r4check; s := 'BFFFO '; end;
	     14: begin m1m3m4m7r1check; s := 'BFSET '; end;
	     15: begin m1m3m4m7r1check; s := 'BFINS '; end;
	   end;
	   saveeax := eax;
	   eax := addr(eax^,2);
	   if hex1 = 15 then
	     begin
	     bfreg;
	     comma;
	     end;
	   dumpea(mode1,reg1,eax,1);
	   offset_width;
	   if hex1 in [9,11,13] then
	     begin
	     comma;
	     bfreg;
	     end;
	   done := true;
	   end
	 else
	   BEGIN { SHIFT / ROTATE }
	   IF OSIZE=3 THEN
	     BEGIN       { MEMORY OPERAND }
	     IF BIT11 THEN ESCAPE(0);
	     M7R1CHECK;
	     IF (MODE1<2) THEN ESCAPE(0);
	     S := STR(SRTYPE,REG2*4+1,3);
	     IF REG2<>2 THEN SETSTRLEN(S,2); { IF NOT ROX, THEN ONLY 2 }
	     IF BIT8 THEN S := S + 'L '   { ADD DIRECTION }
		     ELSE S := S + 'R ';
	     OPC:=19;
	     END
	   ELSE
	     BEGIN       { REGISTER OPERAND }
	     I := MODE1 MOD 4; { IGNORE BIT 5 }
	     S := STR(SRTYPE,I*4+1,3);
	     IF I<>2 THEN SETSTRLEN(S,2);   { IF NOT ROX, THEN ONLY 2 }
	     IF BIT8 THEN S := S + 'L.'  { ADD DIRECTION }
		     ELSE S := S + 'R.';
	     S := S + STR(SSIZE,OSIZE+1,1); BLANK;  { ADD SIZE }
	     IF BIT5 THEN APPENDREG(0,REG2)     { REGISTER OR COUNT }
	     ELSE
	       BEGIN
	       IF REG2=0 THEN K:=8 ELSE K:=REG2;
	       NUMBERSIGN; APPEND_INT(K);
	       END;
	     OPC:=17;
	     END;
	   DONE:= (OPC=16);
	   END;

      17:BEGIN COMMA; APPENDREG(0,REG1); DONE:=TRUE;
	 END;
      18:BEGIN DUMPEA(MODE1,REG1,EAX,OSIZE); DONE:=TRUE;
	 END;
      19:BEGIN DUMPEA(MODE1,REG1,EAX,0); DONE:=TRUE;
	 END;
      20:BEGIN DUMPEA(7,4,EAX,OSIZE); COMMA; OPC:=19;
	 END;
      21:BEGIN DUMPEA(MODE1,REG1,EAX,OSIZE); COMMA; APPENDREG(0,REG2);
	       DONE:=TRUE;
	 END;
      22:BEGIN APPENDREG(0,REG2); COMMA; OPC:=18;
	 END;
      23: { opcode $F }
	 begin
	 if reg2 = 1 then mc68881
	 { Next two lines JWH 12/24/89 : }
	 else if reg2 = 2 then cinv_cpush
	 else if (reg2 = 3) then move16
	 else
	   begin
	   s := '';
	   done := true;
	   end;
	 end;

      OTHERWISE         S :=''; DONE:=TRUE;
      END; { CASE OPC }
      UNTIL DONE;
    RECOVER
    BEGIN
      IF ESCAPECODE=0 THEN
	begin
	S := '';
	eax := original_eax; { advance 2 bytes for illegal instr }
	end
      {ELSE ESCAPE(ESCAPECODE)};
    END;
    NXTP := ORD(EAX);
  END;  { REVASM }

END.    { MODULE REVASM_MOD }

@


56.2
log
@
pws2rcs automatic delta on Wed Jan 27 11:57:27 MST 1993
@
text
@d1 2117
@


56.1
log
@Automatic bump of revision number for PWS version 3.25
@
text
@a0 2117
					       (*

 (c) Copyright Hewlett-Packard Company, 1985.
All rights are reserved.  Copying or other
reproduction of this program except for archival
purposes is prohibited without the prior
written consent of Hewlett-Packard Company.


	    RESTRICTED RIGHTS LEGEND

Use, duplication, or disclosure by the Government
is subject to restrictions as set forth in
paragraph (b) (3) (B) of the Rights in Technical
Data and Computer Software clause in
DAR 7-104.9(a).

HEWLETT-PACKARD COMPANY
Fort Collins, Colorado                         *)

$SYSPROG$ $DEBUG OFF$
$RANGE ON , PARTIAL_EVAL, OVFLCHECK OFF,STACKCHECK OFF$
$COPYRIGHT '(C) 1985 HEWLETT-PACKARD CO. 3.1'$
MODULE REVASM_MOD;
{ This module is used by the debugger for X format execution }
IMPORT ASM;
EXPORT
  PROCEDURE REVASM(ANYVAR INSP:INTEGER; VAR S:STRING;
		   ANYVAR NXTP,FTYPE:INTEGER);
implement
  PROCEDURE REVASM(ANYVAR INSP:INTEGER; VAR S:STRING;
		   ANYVAR NXTP,FTYPE:INTEGER);
  CONST
    MAXOPS = 34;
  TYPE
    UWORD = 0..65535;
    BYTE  = 0..255;
    IWORDA = PACKED ARRAY [1..MAXOPS] OF UWORD;
    INAMEA = ARRAY[1..MAXOPS] OF STRING[13];
    IBYTEA = PACKED ARRAY [1..MAXOPS] OF BYTE;
    REGBITS = PACKED ARRAY[0..15] OF BOOLEAN;
    WORD = -32768..32767;
    SBYTE = -128..127;
    HEXD  = 0..15;
    STRING1 = STRING[1];
    INSTREC = PACKED RECORD
	      CASE INTEGER OF
	      0 :(BYTE0 : BYTE;
		  BYTE1 : SBYTE);
	      1: (OPCODE : 0..15;
		  IREG2   : 0..7;
		  IMODE2  : 0..7;
		  IMODE1  : 0..7;
		  IREG1   : 0..7);
	      2: (IWORD  : UWORD);
	      3: (HEX0   : HEXD;  { OPCODE }
		  HEX1   : HEXD;
		  HEX2   : HEXD;
		  HEX3   : HEXD);
	      4: (BIT15  : BOOLEAN;
		  BIT14  : BOOLEAN;
		  BIT13  : BOOLEAN;
		  BIT12  : BOOLEAN;
		  BIT11  : BOOLEAN;
		  BIT10  : BOOLEAN;
		  BIT9   : BOOLEAN;
		  BIT8   : BOOLEAN;
		  BIT7   : BOOLEAN;
		  BIT6   : BOOLEAN;
		  BIT5   : BOOLEAN;
		  BIT4   : BOOLEAN;
		  BIT3   : BOOLEAN;
		  BIT2   : BOOLEAN;
		  BIT1   : BOOLEAN;
		  BIT0   : BOOLEAN);
	      5: (DUM1   : HEXD;
		  DATA   : 0..7;
		  BITX8  : BOOLEAN;
		  OPSIZE : 0..3;
		  fpredicate : 0..63);
	      6: (DUM2   : HEXD;
		  DUM3   : 0..7;
		  OPSIZE1: 0..3);
	      END;

     EAXREC = PACKED RECORD
	      CASE INTEGER OF
	      1:(EXOFFWORD : WORD);
	      2:(EXOFFLONG : INTEGER);
	      3:(EXB0      : BYTE;
		 EXB1      : BYTE);
	      4:(EXDABIT   : BOOLEAN;
		 EXREG     : 0..7;
		 EXWLBIT   : BOOLEAN;
		 exscale   : 0..3;
		 case fullindex : boolean of
		   false: (exoffbyte : -128..127);
		   true:  (exbs : boolean;
			   exis : boolean;
			   exbdsize : 0..3;
			   expadbit : boolean;
			   exindirect : 0..7));
	      5:(expad1 : hexd;
		 exDo : boolean;
		 exoffset : 0..31;
		 exDw : boolean;
		 exwidth : 0..31);
	      6:(expad2 : 0..127;
		 exDu : 0..7;
		 expad3 : 0..7;
		 exDc : 0..7);
	      7:(fopclas : 0..7;
		 frx : 0..7;
		 fry : 0..7;
		 case integer of
		   0: (fextension : 0..127);
		   1 :(fext : 0..15;
		       sincosreg : 0..7);
		   2: (Kfactor : -64..63);
		   3: (KDreg : 0..7;
		       zeros : 0..15));
	      END;
    EAXRECP = ^EAXREC;
    INSTRP  = ^INSTREC;
    OUTSTR  = STRING[80];

  CONST
    BRATYPE = 'RASRHILSCCCSNEEQVCVSPLMIGELTGTLE';
    CCTYPE  = 'T F HILSCCCSNEEQVCVSPLMIGELTGTLE';
    BITTYPE = 'BTSTBCHGBCLRBSET';
    SSIZE   = 'BWL@@';
    SRTYPE  = 'AS**LS**ROX*RO**';
    OPBITS = IWORDA[ HEX('1000'),HEX('2040'),HEX('2000'),HEX('3040'),
		     HEX('3000'),HEX('6000'),HEX('4E80'),HEX('4EC0'),
		     HEX('4E75'),HEX('4E70'),HEX('4E71'),HEX('4E72'),
		     HEX('4E73'),HEX('4E76'),HEX('4E77'),HEX('7000'),
		     HEX('4E58'),HEX('4880'),HEX('48C0'),HEX('4840'),
		     HEX('4E68'),HEX('4E74')
		     ,HEX('0000'),HEX('4000'),HEX('5000'),HEX('8000'),
		     HEX('9000'),HEX('B000'),HEX('C000'),HEX('D000'),
		     HEX('E000')
		     ,HEX('A000'),HEX('F000'),HEX('0000')];
    OPMASKS= IWORDA[ HEX('F000'),HEX('F1C0'),HEX('F000'),HEX('F1C0'),
		     HEX('F000'),HEX('F000'),HEX('FFC0'),HEX('FFC0'),
		     HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),
		     HEX('FFFF'),HEX('FFFF'),HEX('FFFF'),HEX('F100'),
		     HEX('FFF8'),HEX('FFF8'),HEX('FFF8'),HEX('FFF8'),
		     HEX('FFF8'),HEX('FFFF')
		     ,HEX('F000'),HEX('F000'),HEX('F000'),HEX('F000'),
		     HEX('F000'),HEX('F000'),HEX('F000'),HEX('F000'),
		     HEX('F000')
		     ,HEX('F000'),HEX('F000'),HEX('0000')];
    OPNAMES= INAMEA['MOVE.B ','MOVEA.L ','MOVE.L ','MOVEA.W ',
		    'MOVE.W ','BRA','JSR ','JMP ',
		    'RTS','RESET','NOP','STOP # ',
		    'RTE','TRAPV','RTR','MOVEQ # ',
		    'UNLK A','EXT.W D','EXT.L D','SWAP D',
		    'MOVE USP,A','RTD # '
		    ,'0...','4...','5...','8...',
		    '9...','B...','C...','D...',
		    'E...'
		    ,'A...','F...','DC.W '];
    OPCTRL = IWORDA[2,1,1,1,
		    1,6,3,3,
		    0,0,0,4,
		    0,0,0,7,
		    5,5,5,5,
		    5,4
		    ,8,9,10,11,
		    12,13,14,15,
		    16,
		    65535,23,65535];

  VAR
    EAX   : EAXRECP;
    saveeax : EAXRECP;
    eaxplus2 : EAXRECP;
    original_eax : eaxrecp;
    INSR  : RECORD
	      CASE INTEGER OF
	      0:(INSTP:INSTRP);
	      1:(INSTI:INTEGER);
	    END;
    I,J,K : INTEGER;
    MODE1,REG1,MODE2,REG2 : INTEGER;
    OPC,OSIZE   : INTEGER;
    DONE  : BOOLEAN;

    FUNCTION SREG(I:INTEGER):STRING1;
    BEGIN SREG := ' '; SREG[1] := CHR(I+ORD('0'));
    END;

    PROCEDURE APPENDREG(RT:INTEGER; RN:INTEGER);
    CONST REGNAME='D A FP ';
    BEGIN
      S:=S+STR(REGNAME,RT*2+1,2);
      if rt = 2 { Float reg } then setstrlen(s,strlen(s)+1);
      S[STRLEN(S)]:=CHR(RN+ORD('0'));
    END;
    PROCEDURE COMMA;
    BEGIN S:=S+',';END;
    PROCEDURE NUMBERSIGN;
    BEGIN S:=S+'#';END;
    PROCEDURE BLANK;
    BEGIN S:=S+' ';END;
    PROCEDURE SUFFIX(N:INTEGER);
    CONST SUF='.B .W .L ';
    BEGIN S:=S+STR(SUF,N*3+1,3);END;
    PROCEDURE M7R1CHECK;
    BEGIN IF (MODE1=7) AND (REG1>1) THEN ESCAPE(0);
    END;
    PROCEDURE M7R4CHECK;
    BEGIN IF (MODE1=7) AND (REG1>4) THEN ESCAPE(0);
    END;
    PROCEDURE M1M7R1CHECK;
    BEGIN M7R1CHECK; IF (MODE1=1) THEN ESCAPE(0);
    END;
    PROCEDURE M1M7R4CHECK;
    BEGIN M7R4CHECK; IF (MODE1=1) THEN ESCAPE(0);
    END;

    procedure m1m3m4check;
      begin
      if (mode1=1) or (mode1=3) or (mode1=4) then
	escape(0);
      end;

    procedure m1m3m4m7r1check;
      begin
      m1m3m4check;
      m7r1check;
      end;

    procedure m1m3m4m7r4check;
      begin
      m1m3m4check;
      if (mode1=7) and (reg1=4) then
	escape(0);
      end;

    procedure bfreg; {additional Dreg for bit field ops}
      begin
      strwrite(s,strlen(s)+1,i,'D',saveeax^.exreg:1);
      end;

    procedure offset_width;
      begin
      with saveeax^ do
	begin
	s := s + '{';
	if exDo then
	  strwrite(s,strlen(s)+1,i,'D',exoffset:1)
	else
	  strwrite(s,strlen(s)+1,i,exoffset:1);
	s := s + ':';
	if exDw then
	  strwrite(s,strlen(s)+1,i,'D',exwidth:1,'}')
	else
	  if exwidth = 0 then
	    s := s + '32}'
	  else
	    strwrite(s,strlen(s)+1,i,exwidth:1,'}');
	end;
      end;

    PROCEDURE XREG(VAR XP:EAXREC);
    BEGIN APPENDREG(ORD(XP.EXDABIT),XP.EXREG);
    END;

    PROCEDURE CREG(VAR XP:EAXREC);
    BEGIN
      IF (XP.EXscale<>0) or (xp.fullindex) THEN ESCAPE(0);
      IF XP.EXWLBIT THEN
	IF XP.EXB1=0 THEN S:=S+'USP'
	ELSE if xp.exb1 = 1 then s := s + 'VBR'
	else if xp.exb1 = 2 then s := s + 'CAAR'
	else if xp.exb1 = 3 then s := s + 'MSP'
	else if xp.exb1 = 4 then s := s + 'ISP'
	else if xp.exb1 = 5 then s := s + 'MMUSR' { JWH 12/23/89 }
	else if xp.exb1 = 6 then s := s + 'URP' { JWH 12/23/89 }
	else if xp.exb1 = 7 then s := s + 'SRP' { JWH 12/23/89 }
	else escape(0)
      ELSE
	IF XP.EXB1=0 THEN S:=S+'SFC'
	ELSE if xp.exb1 = 1 then S:=S+'DFC'
	else if xp.exb1 = 2 then s := s + 'CACR'
	else if xp.exb1 = 3 then s := s + 'TC' { JWH 12/23/89 }
	else if xp.exb1 = 4 then s := s + 'ITT0' { JWH 12/23/89 }
	else if xp.exb1 = 5 then s := s + 'ITT1' { JWH 12/23/89 }
	else if xp.exb1 = 6 then s := s + 'DTT0' { JWH 12/23/89 }
	else if xp.exb1 = 7 then s := s + 'DTT1' { JWH 12/23/89 }
	else escape(0);
    END;

    PROCEDURE APPEND_INT(I:INTEGER);
    VAR P:INTEGER;
    BEGIN STRWRITE(S,STRLEN(S)+1,P,I:1);
    END;

    PROCEDURE DUMPEA(MODE,REG:INTEGER; VAR X:EAXRECP; SIZE : INTEGER);
    VAR
      I,D,L : INTEGER;
      savex : eaxrecp;
    BEGIN
      L:=0;
      CASE MODE OF
      0,1: APPENDREG(MODE,REG);
      2: S := S + '(A' + SREG(REG) + ')';
      3: S := S + '(A' + SREG(REG) + ')+';
      4: S := S + '-(A' + SREG(REG) + ')';
      5: BEGIN  { 16 BIT DISPLACEMENT + A REGISTER }
	   STRWRITE(S,STRLEN(S)+1,I,X^.EXOFFWORD:1,'(A',REG:1,')'); L:=2;
	 END;
      6: if not x^.fullindex then
	   if x^.exscale = 0 then
	     BEGIN  { 8 BIT DISPLACEMENT+A REGISTER+INDEX REGISTER }
	     STRWRITE(S,STRLEN(S)+1,I,X^.EXOFFBYTE:1,'(A',REG:1,',');
	     APPENDREG(ORD(X^.EXDABIT),X^.EXREG);
	     SUFFIX(ORD(X^.EXWLBIT)+1); S[STRLEN(S)]:=')'; L:=2;
	     END
	   else
	     begin
	     strwrite(s,strlen(s)+1,i,'(',x^.exoffbyte:1,',A',reg:1,',');
	     appendreg(ord(x^.exdabit),x^.exreg);
	     suffix(ord(x^.exwlbit)+1);
	     setstrlen(s,strlen(s)-1);          { suffix added extra blank }
	     case x^.exscale of
	       1: s := s + '*2)';
	       2: s := s + '*4)';
	       3: s := s + '*8)';
	     end;
	     l := 2;
	     end
	 else
	   begin
	   if x^.exindirect <> 0 then
	     s := s + '(['
	   else
	     s := s + '(';
	   savex := x;
	   x := addr(x^,2);
	   case savex^.exbdsize of
	     1: ;
	     2: begin
		strwrite(s,strlen(s)+1,i,x^.exoffword:1);
		x := addr(x^,2);
		end;
	     3: begin
		strwrite(s,strlen(s)+1,i,x^.exofflong:1);
		x := addr(x^,4);
		end;
	   end;
	   if not savex^.exbs then
	     begin
	     if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
	       comma;
	     strwrite(s,strlen(s)+1,i,'A',reg:1);
	     end;
	   if savex^.exindirect in [5,6,7] then
	     s := s + ']';
	   if not savex^.exis then
	     begin
	     if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
	       comma;
	     appendreg(ord(savex^.exdabit),savex^.exreg);
	     suffix(ord(savex^.exwlbit)+1);
	     setstrlen(s,strlen(s)-1);          { suffix added extra blank }
	     case savex^.exscale of
	       0: ;
	       1: s := s + '*2';
	       2: s := s + '*4';
	       3: s := s + '*8';
	     end;
	     end;
	   if savex^.exindirect in [1,2,3] then
	     s := s + ']';
	   case savex^.exindirect of
	     0,1,5: l := 0;
	     2,6  : begin
		    if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
		      comma;
		    strwrite(s,strlen(s)+1,i,x^.exoffword:1);
		    l := 2;
		    end;
	     3,7  : begin
		    if (s[strlen(s)] <> '(') and (s[strlen(s)] <> '[') then
		      comma;
		    strwrite(s,strlen(s)+1,i,x^.exofflong:1);
		    l := 4;
		    end;
	     4: escape(0);
	   end;
	   s := s + ')';
	   end;
      7: CASE REG OF
	 0: BEGIN { SHORT ABSOLUTE } APPEND_INT(X^.EXOFFWORD); L:=2;
	    END;
	 1: BEGIN { LONG ABSOLUTE } APPEND_INT(X^.EXOFFLONG); L:=4;
	    END;
	 2: BEGIN       { PC + DISPLACEMENT }
	      D := ORD(ADDR(X^))-INSR.INSTI+X^.EXOFFWORD;
	      IF D<0 THEN S := S + '*' ELSE S := S + '*+';
	      APPEND_INT(D); L:=2;
	    END;
	 3: if not x^.fullindex then
	      if x^.exscale = 0 then
		BEGIN       { PC + INDEX REG }
		D := ORD(ADDR(X^))-INSR.INSTI+X^.EXOFFBYTE;
		IF D<0 THEN S := S + '*' ELSE S := S + '*+';
		STRWRITE(S,STRLEN(S)+1,I,D:1,'(');
		APPENDREG(ORD(X^.EXDABIT),X^.EXREG);
		SUFFIX(ORD(X^.EXWLBIT)+1); S[STRLEN(S)]:=')'; L:=2;
		END
	      else
		begin
		if x^.exoffbyte = 0 then
		  strwrite(s,strlen(s)+1,i,'(0,PC,')
		else
		  strwrite(s,strlen(s)+1,i,'(',x^.exoffbyte:1,',PC,');
		appendreg(ord(x^.exdabit),x^.exreg);
		suffix(ord(x^.exwlbit)+1);
		setstrlen(s,strlen(s)-1);          { suffix added extra blank }
		case x^.exscale of
		  1: s := s + '*2)';
		  2: s := s + '*4)';
		  3: s := s + '*8)';
		end;
		l := 2;
		end
	    else
	      begin
	      if x^.exindirect <> 0 then
		s := s + '(['
	      else
		s := s + '(';
	      savex := x;
	      x := addr(x^,2);
	      case savex^.exbdsize of
		1: ;
		2: begin
		   if x^.exoffword = 0 then
		     s := s + '0'
		   else
		     strwrite(s,strlen(s)+1,i,ORD(ADDR(X^))-2-INSR.INSTI+x^.exoffword:1);
		   x := addr(x^,2);
		   end;
		3: begin
		   if x^.exofflong = 0 then
		     s := s + '0'
		   else
		     strwrite(s,strlen(s)+1,i,ORD(ADDR(X^))-2-INSR.INSTI+x^.exofflong:1);
		   x := addr(x^,4);
		   end;
	      end;
	      if (s[strlen(s)] <> '(' ) and (s[strlen(s)] <> '[') then
		comma;
	      if not savex^.exbs then
		s := s + 'PC'
	      else
		s := s + 'ZPC';
	      if savex^.exindirect in [5,6,7] then
		s := s + ']';
	      if not savex^.exis then
		begin
		if (s[strlen(s)] <> '(' ) and (s[strlen(s)] <> '[') then
		  comma;
		appendreg(ord(savex^.exdabit),savex^.exreg);
		suffix(ord(savex^.exwlbit)+1);
		setstrlen(s,strlen(s)-1);          { suffix added extra blank }
		case savex^.exscale of
		  0: ;
		  1: s := s + '*2';
		  2: s := s + '*4';
		  3: s := s + '*8';
		end;
		end;
	      if savex^.exindirect in [1,2,3] then
		s := s + ']';
	      case savex^.exindirect of
		0,1,5: l := 0;
		2,6  : begin
		       if x^.exoffword = 0 then
			 s := s + ',0'
		       else
			 strwrite(s,strlen(s)+1,i,',',x^.exoffword:1);
		       l := 2;
		       end;
		3,7  : begin
		       if x^.exofflong = 0 then
			 s := s + ',0'
		       else
			  strwrite(s,strlen(s)+1,i,',',x^.exofflong:1);
		       l := 4;
		       end;
	      end;
	      s := s + ')';
	      end;
	 4: BEGIN       { IMMEDIATE }
	      NUMBERSIGN;
	      CASE SIZE OF
	      0: BEGIN APPEND_INT(X^.EXOFFBYTE); L:=2;
		 END;
	      1: BEGIN APPEND_INT(X^.EXOFFWORD); L:=2;
		 END;
	      2,3: BEGIN APPEND_INT(X^.EXOFFLONG); L:=4;
		 END;
	      OTHERWISE
	      END;      { CASE SIZE }
	    END;        { REG 4 }
	 OTHERWISE
	 END;   { CASE REG }
      END;      { CASE MODE }
      X := ADDR(X^,L);
    END;        { DUMPEA }

    PROCEDURE DUMPREGBITS(ANYVAR REGLIST : REGBITS;ZFIRST : BOOLEAN);
    VAR
      REGNUM,BITNUM     : INTEGER;
      REGCHAR   : STRING[1];
      LASTREG   : INTEGER;
      NEWLIST,INLIST,DONE       : BOOLEAN;
    BEGIN
      NEWLIST := FALSE; INLIST := FALSE; DONE := FALSE;
      LASTREG := 99;    REGNUM := 0;    REGCHAR := 'D';
      IF ZFIRST THEN BITNUM := 0 ELSE BITNUM := 15;

      REPEAT
	IF REGLIST[BITNUM] THEN
	BEGIN
	  IF REGNUM<>LASTREG+1 THEN
	  BEGIN
	    IF INLIST THEN
	    BEGIN
	      S := S +'-'+REGCHAR+SREG(LASTREG);
	      INLIST := FALSE; NEWLIST := TRUE;
	    END;
	    IF NEWLIST THEN S := S + '/';
	    S := S+REGCHAR+SREG(REGNUM);
	    INLIST := FALSE; NEWLIST := TRUE;
	  END
	  ELSE
	  BEGIN INLIST := TRUE; NEWLIST := FALSE; END;
	  LASTREG := REGNUM;
	END;
	REGNUM := REGNUM + 1;
	IF ZFIRST THEN BITNUM := BITNUM + 1
		  ELSE BITNUM := BITNUM - 1;
	IF REGNUM>7 THEN
	BEGIN
	  IF INLIST THEN S := S + '-'+REGCHAR+SREG(LASTREG);
	  IF REGCHAR='D' THEN
	  BEGIN
	    NEWLIST := LASTREG<>99;     INLIST := FALSE;
	    REGCHAR := 'A'; REGNUM := 0; LASTREG := 99;
	  END
	  ELSE DONE:=TRUE;
	END;
      UNTIL DONE;
    END;

  procedure dumpfea(mode,reg: integer; var x: eaxrecp; size: integer);
    type
      hexarray = array[0..15] of char;
    const
      hex = hexarray['0','1','2','3','4','5','6','7','8','9',
		     'A','B','C','D','E','F'];
    var
      j,l : integer;
      variantrec : packed record case integer of
		     0: (i: integer);
		     1: (h: packed array[1..24] of 0..15);
		     2: (i1,i2,i3: integer);
		   end;
    begin
    if (mode = 7) and (reg = 4) then { Immediate }
      begin
      s := s + '#';
      case size of
	0: {L} BEGIN APPEND_INT(X^.EXOFFLONG); L:=4; END;
	1: {S} begin
	       variantrec.i := x^.exofflong;
	       s := s + '$';
	       for j := 1 to 8 do
		 strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
	       l := 4;
	       end;
	2,3: {X,P} begin
		   variantrec.i1 := x^.exofflong;
		   x := addr(x^,4);
		   variantrec.i2 := x^.exofflong;
		   x := addr(x^,4);
		   variantrec.i3 := x^.exofflong;
		   s := s + '$';
		   for j := 1 to 24 do
		     strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
		   l := 4;
		   end;
	4: {W} BEGIN APPEND_INT(X^.EXOFFWORD); L:=2; END;
	5: {D} begin
	       variantrec.i1 := x^.exofflong;
	       x := addr(x^,4);
	       variantrec.i2 := x^.exofflong;
	       s := s + '$';
	       for j := 1 to 16 do
		 strwrite(s,strlen(s)+1,i,hex[variantrec.h[j]]);
	       l := 4;
	       end;
	6: {B} BEGIN APPEND_INT(X^.EXOFFBYTE); L:=2; END;
	otherwise escape(0);
      end; {case}
      eax := addr(eax^,l);
      end
    else
      dumpea(mode,reg,x,size);
    end;

  procedure dumpfregbits(reglist : byte; zfirst : boolean);
    type
      string1 = string[1];
    var
      variantrec : packed record case boolean of
		     true: (b: byte);
		     false:(a: packed array[0..7] of boolean);
		   end;
      regnum, bitnum, lastbit : integer;

    function makestring(c: char): string1;
      var
	s: string1;
      begin
      setstrlen(s,1);
      s[1] := c;
      makestring := s;
      end;

    procedure hithit; forward;

    procedure hitmiss; forward;

    procedure hithithit;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then
	  hithithit
	else
	  begin
	  s := s + 'FP' + makestring(chr(ord('0')+regnum-1));
	  hitmiss;
	  end
      else
	s := s + 'FP' + makestring(chr(ord('0')+regnum-1));
      end;

    procedure misshit;
      begin
      s := s + '/FP' + makestring(chr(ord('0')+regnum));
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then hithit
				else hitmiss;
      end;

    procedure hitmiss;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then misshit
				else hitmiss;
      end;

    procedure hithit;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if (bitnum = lastbit) then
	begin
	s := s + '-FP' + makestring(chr(ord('0')+regnum-1));
	end
      else if not variantrec.a[bitnum] then
	begin
	s := s + '-FP' + makestring(chr(ord('0')+regnum-1));
	hitmiss;
	end
      else
	begin
	s := s + '-';
	hithithit;
	end;
      end;

    procedure firsthit;
      begin
      s := s + 'FP' + makestring(chr(ord('0')+regnum));
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then hithit
				else hitmiss;
      end;

    procedure firstmiss;
      begin
      if zfirst then bitnum := bitnum + 1
		else bitnum := bitnum - 1;
      regnum := regnum + 1;
      if bitnum <> lastbit then
	if variantrec.a[bitnum] then firsthit
				else firstmiss;
      end;

    begin
    variantrec.b := reglist;
    if zfirst then
      begin
      bitnum := 0;
      lastbit := 8;
      end
    else
      begin
      bitnum := 7;
      lastbit := -1;
      end;
    regnum := 0;
    if variantrec.a[bitnum] then firsthit
			    else firstmiss;
    end;

  procedure appendfloatsize(size : integer);
    begin
    case size of
      0: s := s + '.L ';
      1: s := s + '.S ';
      2: s := s + '.X ';
      3,7: s := s + '.P ';
      4: s := s + '.W ';
      5: s := s + '.D ';
      6: s := s + '.B ';
      otherwise escape(0);
    end; {case}
    end;

  procedure appendfloatcondition(predicate : integer);
    begin
    case predicate of
      0:  s := s + 'F';
      1:  s := s + 'EQ';
      2:  s := s + 'OGT';
      3:  s := s + 'OGE';
      4:  s := s + 'OLT';
      5:  s := s + 'OLE';
      6:  s := s + 'OGL';
      7:  s := s + 'OR';
      8:  s := s + 'UN';
      9:  s := s + 'UEQ';
      10: s := s + 'UGT';
      11: s := s + 'UGE';
      12: s := s + 'ULT';
      13: s := s + 'ULE';
      14: s := s + 'NEQ';
      15: s := s + 'T';
      16: s := s + 'SF';
      17: s := s + 'SEQ';
      18: s := s + 'GT';
      19: s := s + 'GE';
      20: s := s + 'LT';
      21: s := s + 'LE';
      22: s := s + 'GL';
      23: s := s + 'LEG';
      24: s := s + 'NLEG';
      25: s := s + 'NGL';
      26: s := s + 'NLE';
      27: s := s + 'NLT';
      28: s := s + 'NGE';
      29: s := s + 'NGT';
      30: s := s + 'SNE';       {LAF 870407 to match manual}
      31: s := s + 'ST';
      otherwise escape(0);
    end;
    end;

  procedure mc68881;
    begin
    if mode2 = 0 then
      if eax^.fopclas >= 6 then { FMOVEM }
	begin
	s := 'FMOVEM ';
	if eax^.fopclas = 6 then { move to FP data registers }
	  begin
	  saveeax := eax;
	  eax := addr(eax^,2);
	  if (mode1 = 0) or (mode1 = 1) or (mode1 = 4) or
	     ((mode1 = 7) and (reg1 = 4)) then { Dn, An, -(An), Imm }
	    escape(0);
	  dumpea(mode1,reg1,eax,0);
	  comma;
	  if saveeax^.frx = 6 then { D reg }
	    begin
	    if saveeax^.fry <> 0 then escape(0); { check for zero fields }
	    appendreg(0,saveeax^.KDreg);
	    if saveeax^.zeros <> 0 then escape(0); { zero fields ? }
	    end
	  else if saveeax^.frx = 4 then { register mask }
	    begin
	    if saveeax^.fry > 1 then escape(0); { check for zero fields }
	    dumpfregbits(saveeax^.exb1,true);
	    end
	  else escape(0);
	  end
	else { move from FP data registers }
	  begin
	  if (eax^.frx = 2) or (eax^.frx = 6) then
	    begin
	    if eax^.fry <> 0 then escape(0); { check for zero fields }
	    if eax^.frx = 2 then { only allow pre decr }
	      if mode1 <> 4 { -(An) } then escape(0);
	    if eax^.frx = 6 then { do not allow pre decr }
	      if mode1 = 4 { -(An) } then escape(0);
	    if eax^.zeros <> 0 then escape(0); { zero fields ? }
	    appendreg(0,eax^.KDreg);
	    end
	  else if (eax^.frx = 0) or (eax^.frx = 4) then
	    begin
	    if eax^.frx = 0 then { only allow pre decr }
	      if mode1 <> 4 { -(An) } then escape(0);
	    if eax^.frx = 4 then { do not allow pre decr }
	      if mode1 = 4 { -(An) } then escape(0);
	    if eax^.fry > 1 then escape(0); { check for zero fields }
	    if eax^.frx = 0 then dumpfregbits(eax^.exb1,false)
			    else dumpfregbits(eax^.exb1,true);
	    end
	  else escape(0);
	  comma;
	  eax := addr(eax^,2);
	  if (mode1 = 0) or (mode1 = 1) or (mode1 = 3) or
	     ((mode1 = 7) and (reg1 >= 2)) then {Dn, An, (An)+, PC modes, Imm}
	    escape(0);
	  dumpea(mode1,reg1,eax,0);
	  end;
	end
      else if eax^.fopclas >= 4 then { FMOVE sysreg }
	begin
	if eax^.frx in [1,2,4] then
	  s := 'FMOVE '
	else
	  s := 'FMOVEM ';
	if (eax^.fry <> 0) or (eax^.fextension <> 0) then escape(0);
	if eax^.fopclas = 4 then { move to sysregs }
	  begin
	  saveeax := eax;
	  eax := addr(eax^,2);
	  dumpea(mode1,reg1,eax,2);
	  case saveeax^.frx of
	    0: escape(0);
	    1: s := s + ',FPIADDR';
	    2: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + ',FPSTATUS';
	       end;
	    3: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm}
		 escape(0);
	       s := s + ',FPSTATUS/FPIADDR';
	       end;
	    4: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + ',FPCONTROL';
	       end;
	    5: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm}
		 escape(0);
	       s := s + ',FPCONTROL/FPIADDR';
	       end;
	    6: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm }
		 escape(0);
	       s := s + ',FPCONTROL/FPSTATUS';
	       end;
	    7: begin
	       if (mode1 = 1) or (mode1 = 0) or
		  ((mode1 = 7) and (reg1 = 4)) then { An or Dn or Imm }
		 escape(0);
	       s := s + ',FPCONTROL/FPSTATUS/FPIADDR';
	       end;
	  end; {case}
	  end
	else { move from sysregs }
	  begin
	  if ((mode1 = 7) and (reg1 > 1)) then escape(0);
	  case eax^.frx of
	    0: escape(0);
	    1: s := s + 'FPIADDR,';
	    2: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + 'FPSTATUS,';
	       end;
	    3: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPSTATUS/FPIADDR,';
	       end;
	    4: begin
	       if mode1 = 1 then { An } escape(0);
	       s := s + 'FPCONTROL,';
	       end;
	    5: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPIADDR,';
	       end;
	    6: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPSTATUS,';
	       end;
	    7: begin
	       if (mode1 = 1) or (mode1 = 0) then { An or Dn } escape(0);
	       s := s + 'FPCONTROL/FPSTATUS/FPIADDR,';
	       end;
	  end; {case}
	  eax := addr(eax^,2);
	  dumpea(mode1,reg1,eax,0);
	  end;
	end
      else if (eax^.fopclas = 2) and (eax^.frx = 7) then { FMOVECR }
	begin
	if (mode1 <> 0) or (reg1 <> 0) then escape(0);
	s := 'FMOVECR #';
	strwrite(s,strlen(s)+1,i,eax^.fextension:1,',');
	appendreg(2,eax^.fry);
	eax := addr(eax^,2);
	end
      else { general }
	begin
	case eax^.fextension of
	  0: s := 'FMOVE';
	  1: s := 'FINT';
	  2: s := 'FSINH';
	  3: s := 'FINTRZ';     (* LAF 861204 *)
	  4: s := 'FSQRT';
	  6: s := 'FLOGNP1';
	  8: s := 'FETOXM1';
	  9: s := 'FTANH';
	  10:s := 'FATAN';
	  12:s := 'FASIN';
	  13:s := 'FATANH';
	  14:s := 'FSIN';
	  15:s := 'FTAN';
	  16:s := 'FETOX';
	  17:s := 'FTWOTOX';
	  18:s := 'FTENTOX';
	  20:s := 'FLOGN';
	  21:s := 'FLOG10';
	  22:s := 'FLOG2';
	  24:s := 'FABS';
	  25:s := 'FCOSH';
	  26:s := 'FNEG';
	  28:s := 'FACOS';
	  29:s := 'FCOS';
	  30:s := 'FGETEXP';
	  31:s := 'FGETMAN';
	  32:s := 'FDIV';
	  33:s := 'FMOD';
	  34:s := 'FADD';
	  35:s := 'FMUL';
	  36:s := 'FSGLDIV';
	  37:s := 'FREM';
	  38:s := 'FSCALE';
	  39:s := 'FSGLMUL';
	  40:s := 'FSUB';
	  48..55:s := 'FSINCOS';
	  56:s := 'FCMP';
	  58:s := 'FTST';
	  64 : s := 'FSMOVE';   { JWH 12/23/89 }
	  65 : s := 'FSSQRT';   { JWH 12/23/89 }
	  68 : s := 'FDMOVE';   { JWH 12/23/89 }
	  69 : s := 'FDSQRT';   { JWH 12/23/89 }
	  88 : s := 'FSABS';   { JWH 12/23/89 }
	  90 : s := 'FSNEG';   { JWH 12/23/89 }
	  92 : s := 'FDABS';   { JWH 12/23/89 }
	  94 : s := 'FDNEG';   { JWH 12/23/89 }
	  96 : s := 'FSDIV';   { JWH 12/23/89 }
	  98 : s := 'FSADD';   { JWH 12/23/89 }
	  99 : s := 'FSMUL';   { JWH 12/23/89 }
	 100 : s := 'FDDIV';   { JWH 12/23/89 }
	 102 : s := 'FDADD';   { JWH 12/23/89 }
	 103 : s := 'FDMUL';   { JWH 12/23/89 }
	 104 : s := 'FSSUB';   { JWH 12/23/89 }
	 108 : s := 'FDSUB';   { JWH 12/23/89 }
	  otherwise ;
	end; {case}
	if eax^.fopclas = 0 then { source is Freg }
	  begin
	  if (mode1 <> 0) or (reg1 <> 0) then escape(0);
	  blank;
	  appendreg(2,eax^.frx);
	  if (eax^.fextension = 58 {FTST}) or ((eax^.frx = eax^.fry) and
	     (eax^.fextension <> 0 {FMOVE}) and (eax^.fextension < 32)) then
	    { Do not display second op for FTST or "single op" instructions }
	  else
	    begin
	    comma;
	    if eax^.fext = 6 then { FSINCOS }
	      begin
	      appendreg(2,eax^.sincosreg);
	      s := s + ':';
	      end;
	    appendreg(2,eax^.fry);
	    end;
	  eax := addr(eax^,2);
	  end
	else if eax^.fopclas = 2 then { source is <ea> }
	  begin
	  if mode1 = 1 then { An } escape(0);
	  if mode1 = 0 then { Dn }
	    if eax^.frx in [2,3,5] then { size - X,P,D } escape(0);
	  appendfloatsize(eax^.frx);
	  saveeax := eax;
	  eax := addr(eax^,2);
	  dumpfea(mode1,reg1,eax,saveeax^.frx);
	  if  saveeax^.fextension <> 58 {FTST} then
	    begin
	    comma;
	    if saveeax^.fext = 6 then { FSINCOS }
	      begin
	      appendreg(2,saveeax^.sincosreg);
	      s := s + ':';
	      end;
	    appendreg(2,saveeax^.fry);
	    end;
	  end
	else if eax^.fopclas = 3 then { dest is <ea> }
	  begin { FMOVE from MC68881 }
	  s := 'FMOVE';
	  appendfloatsize(eax^.frx);
	  appendreg(2,eax^.fry);
	  if mode1 = 0 {Dreg} then
	    if eax^.frx in [2,3,5,7] then escape(0);
	  if (mode1 = 1) or ((mode1 = 7) and (reg1 > 1)) then
	    escape(0);
	  saveeax := eax;
	  eax := addr(eax^,2);comma;
	  dumpea(mode1,reg1,eax,0);
	  if saveeax^.frx = 3 {size P} then
	    strwrite(s,strlen(s)+1,i,'{#',saveeax^.Kfactor:1,'}')
	  else if saveeax^.frx = 7 {size P} then
	    begin
	    if saveeax^.zeros <> 0 then escape(0);
	    strwrite(s,strlen(s)+1,i,'{D',saveeax^.KDreg:1,'}');
	    end;
	  end
	else escape(0);
	end
    else
      case mode2 of
	1: { FScc, FDBcc, FTRAPcc }
	   begin
	   if mode1 = 1 then
	     s := 'FDB'
	   else if (mode1 = 7) and (reg1 = 4) then
	     s := 'FTRAP'       (* LAF 861204 *)
	   else if (mode1 = 7) and ((reg1 = 2) or (reg1 = 3)) then
	     s := 'FTRAP'       (* LAF 861204 *)
	   else
	     s := 'FS';
	   appendfloatcondition(eax^.exb1);
	   eax := addr(eax^,2);
	   if mode1 = 1 then
	     begin
	     if s = 'FDBF' then
	       s := 'FDBRA '
	     else
		blank;
	     appendreg(0,reg1);
	     comma;
	     s := s + '*';
	     k := eax^.exoffword;
	     k := k +4; { avoid 16 bit math }
	     eax := addr(eax^,2);
	     if k >= 0 then s := s + '+';
	     strwrite(s,strlen(s)+1,i,k:1);
	     end
	   else if (mode1 = 7) and (reg1 = 4) then
	     { FTcc }
	   else if (mode1 = 7) and (reg1 = 2) then
	     begin { FTPcc.W }
	     s := s + '.W #';
	     strwrite(s,strlen(s)+1,i,eax^.exoffword:1);
	     eax := addr(eax^,2);
	     end
	   else if (mode1 = 7) and (reg1 = 3) then
	     begin { FTPcc.L }
	     s := s + '.L #';
	     strwrite(s,strlen(s)+1,i,eax^.exofflong:1);
	     eax := addr(eax^,4);
	     end
	   else
	     begin
	     blank;
	     if (mode1 = 1) or ((mode1 = 7) and (reg1 >= 2)) then
	       escape(0);  { An, PC modes, Imm }
	     dumpea(mode1,reg1,eax,1);
	     end;
	   end;
	2,3: { Revearse assemble FBF *+2 as FNOP }
	     if (insr.instp^.fpredicate = 0) and (mode2 = 2) and
		(eax^.exoffword = 0) then
	       begin { FNOP }
	       eax := addr(eax^,2);
	       s := 'FNOP';
	       end
	     else { FBcc }
	       begin
	       if insr.instp^.fpredicate = 15 {FBT} then
		 s := 'FBRA'
	       else
		 begin
		 s := 'FB';
		 appendfloatcondition(insr.instp^.fpredicate);
		 end;
	       if mode2 = 3 then
		 begin
		 s := s + '.L';
		 j := eax^.exofflong;
		 eax := addr(eax^,4);
		 end
	       else
		 begin
		 j := eax^.exoffword;
		 eax := addr(eax^,2);
		 end;
	       j := j + 2;
	       s := s + ' *';
	       if j >= 0 then s := s + '+';
	       strwrite(s,strlen(s)+1,i,j:1);
	       end;
	4,5: { FSAVE, FRESTORE }
	     begin
	     if mode2 = 4 then
	       begin
	       if (mode1 = 0) or (mode1 = 1) or (mode1 = 3) or
		  ((mode1 = 7) and (reg1 >= 2)) then {Dn, An, (An)+, Imm, PC}
		 escape(0);
	       s := 'FSAVE ';
	       end
	     else
	       begin
	       if (mode1 = 0) or (mode1 = 1) or (mode1 = 4) or
		  ((mode1 = 7) and (reg1 = 4)) then {Dn, An, -(An), Imm}
		 escape(0);
	       s := 'FRESTORE ';
	       end;
	     dumpea(mode1,reg1,eax,1);
	     end;
	otherwise escape(0);
      end {case};
    done := true;
    end; { mc68881 }

  { Added 12/24/89 JWH : }

  procedure move16; { Handle the '040 move16 instruction }
  type move16_type =
	packed record
	  case integer of
	    1: (the_op : byte;
		which : 0..7;
		mode_16 : 0..3;
		reg_ax : 0..7);
	    2: (w : UWORD);
	end; { move16_type }
    type my_word =
	packed record
	  case integer of
	1: (nib1,nib2 : 0..15;
	  byte_it : byte);
	2: (w : WORD);
       end; { my_word type }
    var see_it : move16_type;
    var see_ex : my_word;
    begin
      see_it.w := INSR.INSTP^.IWORD;  { see it as a move16 }
  { So far we've examined only the first 7 bits of the instruction }
      s := 'MOVE16 ';
      with see_it do
       begin
	if the_op <> hex('F6') { $F6 } then escape(0); { First 8 bits }
	if which > 1 then escape(0); { First 11 bits }
	if which = 1 then { have post increment format }
	 begin
	  if mode_16 <> 0 then { gotta be for this format }
	     escape(0); { First 13 bits }
	  if eax^.exDAbit <> TRUE { 1 }  then { gotta be for this format }
	     escape(0); { First 17 bits }
	  see_ex.w := eax^.exoffword;
	  if ((see_ex.nib2 <> 0) or (see_ex.byte_it <> 0)) then
	     escape(0); { All 32 bits checked out }
	  s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  s := s + '+'; { emitpostincr(reg_ax); }
	  comma;
	  s := s + '('; APPENDREG(1,EAX^.EXREG); s := s + ')';
	  s := s + '+';
	  { emitpostincr(ext.exRn1); }
	 end { which = 1 , post increment format }
	else  { which = 0, have absolute format }
	 begin
	   { All 48 bits fit the format at this point ... }
	   case mode_16 of
	    0 : begin s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      s := s + '+'; comma; DUMPEA(7,1,EAX,4); end;
	    1 : begin DUMPEA(7,1,EAX,4); comma;
		      s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      s := s + '+'; end;
	    2 : begin s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
		      comma; DUMPEA(7,1,EAX,4); end;
	    3 : begin DUMPEA(7,1,EAX,4); comma;
		      s := s + '('; APPENDREG(1,reg_ax); s := s + ')'; end;
	    otherwise ; { this really can't happen }
	   end; { case }
	 end; { which = 0, absolute format }
       end; { with see_it }
       done := TRUE;
     end; { move16 }

    { Added 12/24/89 JWH : }

  procedure cinv_cpush; { Handle '040 CINV and CPUSH instructions }
  type cache_40_type =
	packed record
	  case integer of
	    1: (the_op : byte;
		which_caches : 0..3;
		which_instr : 0..1;
		scope : 0..3;
		reg_ax : 0..7);
	    2: (w : UWORD);
	end; { cache_40_type }
    var see_it : cache_40_type;
    begin
     see_it.w := INSR.INSTP^.IWORD; { see it as a cinv or cpush }
  { So far we've examined only the first 7 bits of the instruction }
     with see_it do
      begin
       if the_op <> hex('F4') then escape(0); { First 8 bits }
       if which_instr = 0 then
	begin { CINV }
	 case scope of
	  0 : escape(0); { ILLEGAL }
	  1 : s := 'CINVL ';
	  2 : s := 'CINVP ';
	  3 : s := 'CINVA ';
	  otherwise ;
	 end; { case }
	 case which_caches of
	  0 : s := s + 'NONE'; { NOOP, NOT ILLEGAL }
	  1 : s := s + 'DC';
	  2 : s := s + 'IC';
	  3 : s := s + 'DC/IC';
	  otherwise ;
	 end; { case }
	 if ((scope = 1) or (scope = 2)) then { CINVL or CINVP .. }
	  begin { get the reg ... }
	    comma; s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  end; { CINVL or CINVP }
	end { CINV }
       else
	begin { CPUSH }
	 case scope of
	  0 : escape(0); { ILLEGAL }
	  1 : s := 'CPUSHL ';
	  2 : s := 'CPUSHP ';
	  3 : s := 'CPUSHA ';
	  otherwise ;
	 end; { case }
	 case which_caches of
	  0 : s := s + 'NONE';  { NOOP, NOT ILLEGAL }
	  1 : s := s + 'DC';
	  2 : s := s + 'IC';
	  3 : s := s + 'DC/IC';
	  otherwise ;
	 end; { case }
	 if ((scope = 1) or (scope = 2)) then { CPUSHL or CPUSHP .. }
	  begin { get the register ... }
	    comma; s := s + '('; APPENDREG(1,reg_ax); s := s + ')';
	  end; { CPUSHL or CPUSHP }
	end; { CPUSH }
      end; { with see_it }
      done := TRUE;
    end; { cinv_cpush }

  {************************************************************}
  {************************************************************}
  BEGIN { REV ASM }
    INSR.INSTI:=INSP;
    EAX := ADDR(INSR.INSTP^,2);
    original_eax := eax;
    SETSTRLEN(S,0);
    WITH INSR.INSTP^ DO
    TRY
      MODE1:=IMODE1; MODE2:=IMODE2; REG1:=IREG1; REG2:=IREG2;
      I:=1; DONE := FALSE;
      WHILE IAND(IWORD,OPMASKS[I])<>OPBITS[I] DO I := I + 1;
      OPC :=OPCTRL[I]; S := OPNAMES[I]; OSIZE:=OPSIZE;
      REPEAT
      CASE OPC OF
      0:DONE:=TRUE; {NO OPERANDS}
      1:BEGIN   { MOVE.B .W .L }
	  M7R4CHECK;
	  IF MODE2=7 THEN IF REG2>1 THEN ESCAPE(0);
	  IF OPCODE=1 THEN
	    begin
	    if mode1 = 1 {An} then escape(0);
	    OSIZE:=0;
	    end
	  ELSE
	    IF OPCODE=2 THEN OSIZE:=2 ELSE OSIZE:=1;
	  DUMPEA(MODE1,REG1,EAX,OSIZE);
	  COMMA;
	  DUMPEA(MODE2,REG2,EAX,OSIZE);
	  DONE := TRUE;
	END;
      2:IF MODE2=1 THEN ESCAPE(0) ELSE OPC:=1;  { MOVE.B }
      3:BEGIN   {JMP OR JSR}
	  IF (MODE1=2) OR (MODE1>4) THEN
	  BEGIN IF (MODE1=7) AND (REG1>3) THEN ESCAPE(0); END
	  ELSE ESCAPE(0);
	  OPC:=19;
	END;
      4:BEGIN   { STOP, RTD }
	  STRWRITE(S,STRLEN(S),I,EAX^.EXOFFWORD:1);
	  EAX := ADDR(EAX^,2);
	  DONE := TRUE;
	END;
      5:BEGIN  { REG IS ONLY ARG }
	  S := S+SREG(REG1); DONE := TRUE;
	END;
      6:BEGIN   {Bcc, BRA, BSR}
	  J := HEX1 * 2 + 1;
	  S[2]:=BRATYPE[J]; S[3]:=BRATYPE[J+1];
	  if byte1 = -1 then {32 bit disp}
	    begin
	    j := eax^.exofflong;
	    eax := addr(eax^,4);
	    s := s + '.L';
	    end
	  else IF BYTE1<>0 THEN
	    BEGIN J := BYTE1; S := S + '.S'; END
	  ELSE
	    BEGIN J := EAX^.EXOFFWORD; EAX := ADDR(EAX^,2); END;
	  S := S + ' *';
	  IF J>=(-2) THEN S := S + '+';
	  if j = maxint then
	    s := s + '2147483649'
	  else if j = maxint-1 then
	    s := s + '2147483648'
	  else
	    STRWRITE(S,STRLEN(S)+1,I,J+2:1);
	  DONE := TRUE;
	END;
      7:BEGIN
	  STRWRITE(S,STRLEN(S),I,BYTE1:1,',D',REG2:1); DONE:=TRUE;
	END;
      8:BEGIN   { OPCODE 0 }
	  IF BIT8 AND (MODE1=1) THEN
	    BEGIN        { MOVEP }
	    S := 'MOVEP'; SUFFIX(ORD(BIT6)+1);


	    IF BIT7 THEN
	      BEGIN
	      APPENDREG(0,REG2); COMMA; APPEND_INT(EAX^.EXOFFWORD);
	      STRWRITE(S,STRLEN(S)+1,I,'(A',SREG(REG1),')');
	      END
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,EAX^.EXOFFWORD:1,
	       '(A',SREG(REG1),'),D',SREG(REG2));
	    EAX := ADDR(EAX^,2);       { SKIP THE OFFSET }
	    END          { MOVEP }
	  ELSE
	    BEGIN
	    IF BIT8 OR (REG2=4) THEN
	      BEGIN      { BTST, BCHG, BCLR, BSET }
	      if mode1 = 1 then escape(0);
	      if mode1 = 7 then
		if osize = 0 { BTST } then
		  begin
		  if not bit8 and (reg1 > 3) then escape(0);
		  end
		else if reg1 > 1 then escape(0);
	      S := STR(BITTYPE,OSIZE*4+1,4);
	      IF BIT8 THEN     { BIT # IS IN D REG }
		      BEGIN BLANK; APPENDREG(0,REG2); COMMA; END
	      ELSE
		BEGIN            { BIT # IS IMMEDIATE }
		K := EAX^.EXB1;
		IF MODE1=0 THEN K := K MOD 32 ELSE K := K MOD 8;
		BLANK; NUMBERSIGN; APPEND_INT(K); COMMA;
		EAX := ADDR(EAX^,2);
		END;
	      OPC:=19;
	      END        { BIT OPS }
	    ELSE if bit11 and (opsize=3) then { CAS, CAS2 }
	      if (mode1 = 7) and (reg1 = 4) then { CAS2 }
		begin
		eaxplus2 := addr(eax^,2);
		case reg2 of
		  5: s := 'CAS2.B';
		  6: s := 'CAS2.W';
		  7: s := 'CAS2.L';
		  otherwise escape(0);
		end;
		strwrite(s,strlen(s)+1,i,
			   ' D',eax^.exDc:1,':D',eaxplus2^.exDc:1,
			   ',D',eax^.exDu:1,':D',eaxplus2^.exDu:1,',(');
		if eax^.exdabit then s := s + 'A'
				else s := s + 'D';
		strwrite(s,strlen(s)+1,i,eax^.exreg:1,'):(');
		if eaxplus2^.exdabit then s := s + 'A'
				     else s := s + 'D';
		strwrite(s,strlen(s)+1,i,eaxplus2^.exreg:1,')');
		eax := addr(eax^,4);
		end
	      else { CAS }
		begin
		m1m7r1check;
		if mode1 = 0 {Dn} then escape(0);
		case reg2 of
		  5: s := 'CAS.B D';
		  6: s := 'CAS.W D';
		  7: s := 'CAS.L D';
		  otherwise escape(0);
		end;
		strwrite(s,strlen(s)+1,i,eax^.exDc:1,',','D',eax^.exDu:1,',');
		eax := addr(eax^,2);
		opc := 19;
		end
	    else if (opsize = 3) and (reg2 < 3) then {CHK2 CMP2}
	      begin
	      m1m3m4check;
	      if (mode1 = 0) or ((mode1 = 7) and (reg1 = 4)) then escape(0);
	      if eax^.exwlbit then s := 'CHK2'
			      else s := 'CMP2';
	      case reg2 of
		0: s := s + '.B ';
		1: s := s + '.W ';
		2: s := s + '.L ';
	      end;
	      saveeax := eax;
	      eax := addr(eax^,2);
	      DUMPEA(MODE1,REG1,EAX,0);
	      comma;
	      if saveeax^.exdabit then s := s + 'A'
				  else s := s + 'D';
	      strwrite(s,strlen(s)+1,i,saveeax^.exreg:1);
	      end
	    else
	      BEGIN
	      CASE HEX1 OF
	      0,2,10:
		 BEGIN { ORI, ANDI, EORI }
		 IF HEX1=0 THEN S := 'ORI'
		 ELSE
		   IF HEX1=2 THEN S := 'ANDI'
		   ELSE
		   IF HEX1=10 THEN S := 'EORI';

		 IF (MODE1=7) AND (REG1=4) THEN
		   BEGIN       { op to CCR or SR }
		   IF OSIZE>1 THEN ESCAPE(0);
		   BLANK;
		   IF HEX2=3 THEN
		     begin
		     dumpea(7,4,eax,0);
		     S := S + ',CCR';
		     end
		   ELSE
		     begin
		     dumpea(7,4,eax,1);
		     S := S + ',SR';
		     end;
		   END
		 ELSE
		   BEGIN
		   M1M7R1CHECK;
		   IF OSIZE=3 THEN ESCAPE(0);
		   S := S + '.' + STR(SSIZE,OSIZE+1,1); BLANK;
		   OPC:=20;
		   END;
		 END;
	      4,6: if opsize = 3 then { RTM, CALLM }
		     if mode1 <= 1 then { RTM }
		       begin
		       if mode1 = 0 then s := 'RTM D'
				    else s := 'RTM A';
		       strwrite(s,strlen(s)+1,i,reg1:1);
		       end
		     else { CALLM }
		       begin
		       m1m3m4m7r4check;
		       if (mode1 = 0) then escape(0);
		       s := 'CALLM #';
		       strwrite(s,strlen(s)+1,i,eax^.exb1:1);
		       comma;
		       eax := addr(eax^,2);
		       opc := 19;
		       end
		   else
		     BEGIN       { ADDI, SUBI }
		     M1M7R1CHECK;
		     IF OSIZE=3 THEN ESCAPE(0);
		     IF HEX1=4 THEN S := 'SUBI.' ELSE S := 'ADDI.';
		     S := S + STR(SSIZE,OSIZE+1,1); BLANK;
		     OPC:=20;
		     END;
	      12:BEGIN {CMPI}
		 if (mode1 = 1) or ((mode1 = 7) and (reg1 = 4)) then
		   escape(0);
		 IF OSIZE=3 THEN ESCAPE(0);
		 STRWRITE(S,1,I,'CMPI.',SSIZE[OSIZE+1]); BLANK;
		 OPC:=20;
		 END;
	      14:BEGIN {MOVES}
		 M7R1CHECK;
		 IF (MODE1<2) OR (OSIZE=3) THEN ESCAPE(0);
		 STRWRITE(S,1,I,'MOVES.',SSIZE[OSIZE+1]); BLANK;
		 I:=ORD(EAX^.EXDABIT); J:=ORD(EAX^.EXREG);
		 IF EAX^.EXWLBIT THEN
		   BEGIN
		   XREG(EAX^); COMMA; EAX:=ADDR(EAX^,2);
		   DUMPEA(MODE1,REG1,EAX,OSIZE);
		   END
		 ELSE
		   BEGIN
		   eax := addr(eax^,2);
		   DUMPEA(MODE1,REG1,EAX,OSIZE); COMMA; APPENDREG(I,J);
		   END;
		 END;
	      OTHERWISE ESCAPE(0)       { INVALID INSTRUCTION }
	      END;
	    END;
	  END;
	  DONE:=(OPC=8);
	END;
      9:BEGIN  { OPCODE 4 }
	  IF BIT8 THEN
	    BEGIN        { CHK, LEA, EXTB }
	    IF (OSIZE=2) or (osize = 0) THEN
	      BEGIN      { CHK }
	      IF MODE1=1 THEN ESCAPE(0);
	      if mode2 = 6 then
		begin
		S := 'CHK.W ';
		DUMPEA(MODE1,REG1,EAX,1);
		end
	      else if mode2 = 4 then
		begin
		s := 'CHK.L ';
		DUMPEA(MODE1,REG1,EAX,2);
		end
	      else escape(0);
	      COMMA; APPENDREG(0,REG2);
	      END
	    else if mode1 = 0 then { EXTB }
	      begin
	      s := 'EXTB.L ';
	      appendreg(0,reg1);
	      end
	    else if mode2 = 7 then
	      BEGIN      { LEA }
	      IF (MODE1<2) OR (MODE1=3) OR (MODE1=4) OR
		((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
		S := 'LEA ';
		DUMPEA(MODE1,REG1,EAX,2); COMMA; APPENDREG(1,REG2);
	      END
	    else escape(0);
	    END  { CHK , LEA }
	  ELSE
	  CASE HEX1 OF
	  0: BEGIN
	       M1M7R1CHECK;
	       IF OSIZE=3 THEN S := 'MOVE SR,'
			  ELSE S := 'NEGX.'+STR(SSIZE,OSIZE+1,1)+' ';
	       OPC:=18;
	     END;
	  2: BEGIN
	       M1M7R1CHECK;
	       IF OSIZE=3 THEN
	       BEGIN    { MOVE from CCR }
		 S:='MOVE CCR,';DUMPEA(MODE1,REG1,EAX,1);
	       END
	       ELSE
	       BEGIN    { CLR }
		 S := 'CLR.'+STR(SSIZE,OSIZE+1,1); BLANK; OPC:=18;
	       END;
	     END;
	  4: BEGIN
	       IF MODE1=1 THEN ESCAPE(0);
	       IF OSIZE=3 THEN
	       BEGIN   { MOVE TO CCR }
		 S := 'MOVE ';
		 DUMPEA(MODE1,REG1,EAX,1); S := S + ',CCR';
	       END
	       ELSE
	       BEGIN   { NEG }
		 M7R1CHECK;
		 S := 'NEG.'+STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=18;
	       END;
	     END;
	  6: BEGIN
	       IF MODE1=1 THEN ESCAPE(0);
	       IF OSIZE=3 THEN
	       BEGIN   { MOVE TO SR }
		 S := 'MOVE ';
		 DUMPEA(MODE1,REG1,EAX,1); S := S + ',SR';
	       END
	       ELSE
	       BEGIN   { NOT }
		 M7R1CHECK;
		 S := 'NOT.'+STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=18;
	       END;
	     END;
	  8: BEGIN
	     IF BIT7 THEN
	       BEGIN { MOVEM TO EA or EXT.W or EXT.L }
		 IF MODE1=0 THEN
		 BEGIN
		 s := 'EXT';
		 SUFFIX(ORD(BIT6)+1); BLANK; APPENDREG(0,REG1);
		 END
		 ELSE
		 BEGIN { MOVEM TO EA }
		   M7R1CHECK;
		   IF (MODE1<2) OR (MODE1=3) THEN ESCAPE(0);
		   S:='MOVEM'; SUFFIX(ORD(BIT6)+1);
		   DUMPREGBITS(EAX^,MODE1=4);
		   EAX := ADDR(EAX^,2); COMMA;
		   OPC:=19;
		 END;
	       END
	     ELSE if (hex2 = 0) and bit3 then {LINK.L}
	       begin
	       strwrite(s,1,i,'LINK.L A',reg1:1,',#',eax^.exofflong:1);
	       eax := addr(eax^,4);
	       end
	     else IF OSIZE=0 THEN
	       BEGIN { NBCD }
	       M1M7R1CHECK; S := 'NBCD '; OPC:=19;
	       END
	     ELSE if mode1 = 1 then {BKPT}
	       begin
	       s := 'BKPT #';
	       strwrite(s,strlen(s)+1,i,reg1:1);
	       end
	     else
	       BEGIN
	       IF MODE1=0 THEN S := 'SWAP D'+SREG(REG1)
	       ELSE
		 BEGIN { PEA }
		 IF (MODE1<2) OR (MODE1=3) OR (MODE1=4) OR
		    ((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
		 S := 'PEA '; DUMPEA(MODE1,REG1,EAX,2);
		 END;
	       END;
	     END;
	  10:if iword = hex('4AFC') then
	       s := 'ILLEGAL'
	     else
	       BEGIN     { TST, TAS }
		 if osize = 3 {TAS} then
		 M1M7R1CHECK;
		 if osize = 0 {TST.B} then
		   if mode1 = 1 then escape(0);
		 IF OSIZE=3 THEN S := 'TAS '
			    ELSE S := 'TST.' + STR(SSIZE,OSIZE+1,1) + ' ';
		 OPC:=19;
	       END;
	  12:if bit7 then
	       BEGIN     { MOVEM EA TO REGS }
	       IF (MODE1<2) OR (MODE1=4) OR
		  ((MODE1=7) AND (REG1>3)) THEN ESCAPE(0);
	       S:='MOVEM'; SUFFIX(ORD(BIT6)+1);
	       EAX := ADDR(EAX^,2);
	       DUMPEA(MODE1,REG1,EAX,2); COMMA;
	       INSR.INSTP := ADDR(INSR.INSTP^,2);
	       DUMPREGBITS(INSR.INSTP^,FALSE);
	       END
	     else if bit6 then {DIVS.L DIVU.L}
	       begin
	       m1m7r4check;
	       if eax^.exwlbit then s := 'DIVS'
			       else s := 'DIVU';
	       if eax^.exscale = 2 then s := s + '.L '
	       else if eax^.exreg = eax^.exoffbyte then
		 s := s + '.L '
	       else
		 s := s + 'L.L ';
	       saveeax := eax;
	       eax := addr(eax^,2);
	       dumpea(mode1,reg1,eax,2);
	       comma;
	       if (saveeax^.exreg <> saveeax^.exoffbyte) or
		  (saveeax^.exscale = 2) then
		 begin
		 appendreg(0,saveeax^.exoffbyte);
		 s := s + ':';
		 end;
	       appendreg(0,saveeax^.exreg);
	       end
	     else {MULS or MULU}
	       begin
	       m1m7r4check;
	       if eax^.exwlbit then s := 'MULS.L '
			       else s := 'MULU.L ';
	       saveeax := eax;
	       eax := addr(eax^,2);
	       dumpea(mode1,reg1,eax,2);
	       comma;
	       if saveeax^.exscale = 2 then
		 begin
		 appendreg(0,saveeax^.exoffbyte);
		 s := s + ':'
		 end;
	       appendreg(0,saveeax^.exreg);
	       end;
	  14:BEGIN
	       CASE HEX2 OF
	       4: STRWRITE(S,1,I,'TRAP #',HEX3:1);
	       5: BEGIN
		    IF BIT3 THEN STRWRITE(S,1,I,'UNLK A',REG1:1)
		    ELSE
		    BEGIN
		      STRWRITE(S,1,I,'LINK.W A',REG1:1,',#',EAX^.EXOFFWORD:1);
		      EAX := ADDR(EAX^,2);
		    END;
		  END;
	       6: BEGIN {MOVE USP,..  or MOVE ..,USP}
		    IF BIT3 THEN S := 'MOVE USP,A' + SREG(REG1)
			    ELSE S := 'MOVE A'+ SREG(REG1) + ',USP';
		  END;
	       7: BEGIN {MOVEC}
		    S:='MOVEC ';
		    IF HEX3=11 THEN BEGIN XREG(EAX^); COMMA; CREG(EAX^);
				    END
		    ELSE
		    IF HEX3=10 THEN BEGIN CREG(EAX^); COMMA; XREG(EAX^);
				    END
			       ELSE ESCAPE(0);
		    EAX:=ADDR(EAX^,2);
		  END;
		 OTHERWISE  ESCAPE(0)   { INVALID INSTRUCTION }
	       END;    { CASE HEX2 }
	     END;
	     OTHERWISE  ESCAPE(0)   { INVALID INSTRUCTION }
	  END; { CASE HEX1 }
	  DONE:=(OPC=9);
	END;   { OPCODE 4 }
     10:if (hex2 = 15) and bit3 and (reg1 in [2,3,4]) then { TRAPcc }
	  begin
	  case hex1 of
	    0: s := 'TRAPT';
	    1: s := 'TRAPF';
	    2: s := 'TRAPHI';
	    3: s := 'TRAPLS';
	    4: s := 'TRAPCC';
	    5: s := 'TRAPCS';
	    6: s := 'TRAPNE';
	    7: s := 'TRAPEQ';
	    8: s := 'TRAPVC';
	    9: s := 'TRAPVS';
	    10: s := 'TRAPPL';
	    11: s := 'TRAPMI';
	    12: s := 'TRAPGE';
	    13: s := 'TRAPLT';
	    14: s := 'TRAPGT';
	    15: s := 'TRAPLE';
	  end;
	  if reg1 = 2 then { .W }
	    begin
	    strwrite(s,strlen(s)+1,i,'.W #',eax^.exoffword:1);
	    eax := addr(eax^,2);
	    end
	  else if reg1 = 3 then { .L }
	    begin
	    strwrite(s,strlen(s)+1,i,'.L #',eax^.exofflong:1);
	    eax := addr(eax^,4);
	    end;
	  done := true;
	  end
	else
	  BEGIN  { ADDQ or SUBQ or Scc or DBcc }
	  IF OSIZE=3 THEN
	    BEGIN
	    J := HEX1 * 2 + 1;
	    IF MODE1=1 THEN
	      BEGIN
	      if j = 1 then
		STRWRITE(S,1,I,'DBT D',REG1:1,',*')
	      else if j = 3 then
		STRWRITE(S,1,I,'DBRA D',REG1:1,',*')
	      else
		STRWRITE(S,1,I,'DB',STR(CCTYPE,J,2),' D',REG1:1,',*');
	      K := EAX^.EXOFFWORD;
	      k := k +2; { avoid 16 bit math }
	      EAX := ADDR(EAX^,2);
	      IF K>=0 THEN S := S + '+';
	      STRWRITE(S,STRLEN(S)+1,I,K:1);
	      END
	    ELSE
	      BEGIN
	      M7R1CHECK; S:='S   ';
	      if j = 1 then
		s := 'ST '
	      else if j = 3 then
		s := 'SF '
	      else
		STRWRITE(S,2,I,STR(CCTYPE,J,2));
	      OPC:=19;
	      END;
	    END
	  ELSE
	    BEGIN
	    IF (MODE1=1) AND (OSIZE=0) THEN ESCAPE(0);
	    M7R1CHECK;
	    IF BIT8 THEN S := 'SUBQ.' ELSE S := 'ADDQ.';
	    J := DATA; IF J=0 THEN J:=8;
	    STRWRITE(S,STRLEN(S)+1,I,SSIZE[OSIZE+1],' #',J:1,',');
	    OPC:=18;
	    END;
	  DONE:=(OPC=10);
	  END;
     11:BEGIN { OR DIVU DIVS SBCD }
	IF (MODE2=3) OR (MODE2=7) THEN
	    BEGIN        { DIVU or DIVS }
	    M1M7R4CHECK;
	    IF MODE2=3 THEN S := 'DIVU.W ' ELSE S := 'DIVS.W ';
	    DUMPEA(MODE1,REG1,EAX,1); COMMA; APPENDREG(0,REG2);
	    END
	ELSE IF bit8 AND (MODE1<2) THEN
	  if mode2 = 4 then
	    BEGIN        { SBCD }
	    IF BIT3 THEN
	      STRWRITE(S,1,I,'SBCD -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,1,I,'SBCD D',REG1:1,',D',REG2:1)
	    END
	  else { PACK UNPK }
	    begin
	    if mode2 = 5 then s := 'PACK '
			 else s := 'UNPK ';
	    if mode1 = 0 then { D reg }
	      strwrite(s,strlen(s)+1,i,'D',reg1:1,',D',reg2:1,
						      ',#',eax^.exoffword:1)
	    else { -(A reg) }
	      strwrite(s,strlen(s)+1,i,'-(A',reg1:1,'),-(A',reg2:1,
						  '),#',eax^.exoffword:1);
	    eax := addr(eax^,2);
	    end
	ELSE
	  BEGIN        { OR }
	  S := 'OR.' + STR(SSIZE,OSIZE+1,1); BLANK;
	  IF BIT8 THEN
	    BEGIN M7R1CHECK; OPC:=22; END
	  ELSE
	    BEGIN M1M7R4CHECK; OPC:=21; END;
	  END;
	DONE:=(OPC=11);
	END;
     12:BEGIN  { SUB , SUBA or SUBX }
	  IF OSIZE=3 THEN
	  BEGIN
	    M7R4CHECK;
	    S:='SUBA'; SUFFIX(ORD(BIT8)+1);
	    DUMPEA(MODE1,REG1,EAX,OPSIZE1); COMMA; APPENDREG(1,REG2);
	  END
	  ELSE
	  IF BIT8 AND (MODE1<2) THEN
	  BEGIN        { SUBX }
	    S := 'SUBX.'+STR(SSIZE,OSIZE+1,1);
	    IF BIT3 THEN
	      STRWRITE(S,STRLEN(S)+1,I,' -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,' D',REG1:1,',D',REG2:1);
	  END
	  ELSE
	  BEGIN        { SUB }
	    S := 'SUB.'+STR(SSIZE,OSIZE+1,1); BLANK;
	    IF BIT8 THEN
	    BEGIN      { DESTINATION IS <EA> }
	      M7R1CHECK;
	      IF (MODE1<2) THEN ESCAPE(0);
	      OPC:=22;
	    END
	    ELSE
	    BEGIN
	      IF (OSIZE=0) AND (MODE1=1) THEN ESCAPE(0);
	      OPC:=21;
	    END;
	  END;
	  DONE:=(OPC=12);
	END;
     13:BEGIN { CMP ,CMPA, CMPM,  EOR }
	   IF OSIZE=3 THEN
	   BEGIN       { CMPA }
	     S := 'CMPA'; SUFFIX(ORD(BIT8)+1);
	     DUMPEA(MODE1,REG1,EAX,ORD(BIT8)+1); COMMA; APPENDREG(1,REG2);
	   END
	   ELSE
	   BEGIN
	     IF BIT8 THEN
	     BEGIN
	       IF MODE1=1 THEN
		 S := 'CMPM.' + STR(SSIZE,OSIZE+1,1) + ' (A' + SREG(REG1) +
			 ')+,(A' + SREG(REG2) + ')+'
	       ELSE
	       BEGIN { EOR }
		 M7R1CHECK;
		 S := 'EOR.' + STR(SSIZE,OSIZE+1,1); BLANK;
		 OPC:=22;
	       END;
	     END
	     ELSE
	     BEGIN       { CMP }
	       IF (MODE1=1) AND (MODE2=0) THEN ESCAPE(0);
	       S := 'CMP.' + STR(SSIZE,MODE2+1,1); BLANK;
	       DUMPEA(MODE1,REG1,EAX,MODE2); COMMA; APPENDREG(0,REG2);
	     END;
	   END;
	   DONE:=(OPC=13);
	 END;
     14:BEGIN  { AND, MULU, MULS, ABCD }
	       { EXG                   }
	  IF (MODE2=3) OR (MODE2=7) THEN
	  BEGIN        { MULU or MULS }
	    M1M7R4CHECK;
	    IF MODE2=3 THEN S := 'MULU.W '
		       ELSE S := 'MULS.W ';
	    DUMPEA(MODE1,REG1,EAX,1); COMMA; APPENDREG(0,REG2);
	  END
	  ELSE
	  IF (MODE2=4) AND (MODE1<2) THEN
	  BEGIN        { ABCD }
	    IF BIT3 THEN
	      STRWRITE(S,1,I,'ABCD -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,1,I,'ABCD D',REG1:1,',D',REG2:1)
	  END
	  ELSE
	  IF (MODE2=6) AND (MODE1=1) THEN
	     STRWRITE(S,1,I,'EXG D',REG2:1,',A',REG1:1)
	  ELSE
	  IF (MODE2=5) AND (MODE1=0) THEN
	     STRWRITE(S,1,I,'EXG D',REG2:1,',D',REG1:1)
	  ELSE
	  IF (MODE2=5) AND (MODE1=1) THEN
	     STRWRITE(S,1,I,'EXG A',REG2:1,',A',REG1:1)
	  ELSE
	  BEGIN        { AND }
	   S := 'AND.' + STR(SSIZE,OSIZE+1,1); BLANK;
	   IF BIT8 THEN
	   BEGIN
	     M7R1CHECK;
	     IF (MODE1<2) THEN ESCAPE(0);
	     OPC:=22;
	   END
	   ELSE
	   BEGIN
	     M1M7R4CHECK; OPC:=21;
	   END;
	  END;
	  DONE:=(OPC=14);
	 END;
     15: BEGIN { ADD , ADDA or ADDX }
	  IF OSIZE=3 THEN
	  BEGIN
	    M7R4CHECK;
	    S := 'ADDA'; SUFFIX(ORD(BIT8)+1);
	    DUMPEA(MODE1,REG1,EAX,OPSIZE1); COMMA; APPENDREG(1,REG2);
	  END
	  ELSE
	  IF BIT8 AND (MODE1<2) THEN
	  BEGIN        { ADDX }
	    S := 'ADDX.'+STR(SSIZE,OSIZE+1,1);
	    IF BIT3 THEN
	      STRWRITE(S,STRLEN(S)+1,I,' -(A',REG1:1,'),-(A',REG2:1,')')
	    ELSE
	      STRWRITE(S,STRLEN(S)+1,I,' D',REG1:1,',D',REG2:1);
	  END
	  ELSE
	  BEGIN      { ADD }
	    S := 'ADD.'+STR(SSIZE,OSIZE+1,1); BLANK;
	    IF BIT8 THEN
	    BEGIN    { DESTINATION IS <EA> }
	      M7R1CHECK;
	      IF (MODE1<2) THEN ESCAPE(0);
	      OPC:=22;
	    END
	    ELSE
	    BEGIN
	      IF (OSIZE=0) AND (MODE1=1) THEN ESCAPE(0);
	      OPC:=21;
	    END;
	  END;
	  DONE:=(OPC=15);
	 END;
      16:if bit11 and bit7 and bit6 then {bit field instr}
	   begin
	   case hex1 of
	     8: begin m1m3m4m7r4check; s := 'BFTST '; end;
	     9: begin m1m3m4m7r4check; s := 'BFEXTU '; end;
	     10: begin m1m3m4m7r1check; s := 'BFCHG '; end;
	     11: begin m1m3m4m7r4check; s := 'BFEXTS '; end;
	     12: begin m1m3m4m7r1check; s := 'BFCLR '; end;
	     13: begin m1m3m4m7r4check; s := 'BFFFO '; end;
	     14: begin m1m3m4m7r1check; s := 'BFSET '; end;
	     15: begin m1m3m4m7r1check; s := 'BFINS '; end;
	   end;
	   saveeax := eax;
	   eax := addr(eax^,2);
	   if hex1 = 15 then
	     begin
	     bfreg;
	     comma;
	     end;
	   dumpea(mode1,reg1,eax,1);
	   offset_width;
	   if hex1 in [9,11,13] then
	     begin
	     comma;
	     bfreg;
	     end;
	   done := true;
	   end
	 else
	   BEGIN { SHIFT / ROTATE }
	   IF OSIZE=3 THEN
	     BEGIN       { MEMORY OPERAND }
	     IF BIT11 THEN ESCAPE(0);
	     M7R1CHECK;
	     IF (MODE1<2) THEN ESCAPE(0);
	     S := STR(SRTYPE,REG2*4+1,3);
	     IF REG2<>2 THEN SETSTRLEN(S,2); { IF NOT ROX, THEN ONLY 2 }
	     IF BIT8 THEN S := S + 'L '   { ADD DIRECTION }
		     ELSE S := S + 'R ';
	     OPC:=19;
	     END
	   ELSE
	     BEGIN       { REGISTER OPERAND }
	     I := MODE1 MOD 4; { IGNORE BIT 5 }
	     S := STR(SRTYPE,I*4+1,3);
	     IF I<>2 THEN SETSTRLEN(S,2);   { IF NOT ROX, THEN ONLY 2 }
	     IF BIT8 THEN S := S + 'L.'  { ADD DIRECTION }
		     ELSE S := S + 'R.';
	     S := S + STR(SSIZE,OSIZE+1,1); BLANK;  { ADD SIZE }
	     IF BIT5 THEN APPENDREG(0,REG2)     { REGISTER OR COUNT }
	     ELSE
	       BEGIN
	       IF REG2=0 THEN K:=8 ELSE K:=REG2;
	       NUMBERSIGN; APPEND_INT(K);
	       END;
	     OPC:=17;
	     END;
	   DONE:= (OPC=16);
	   END;

      17:BEGIN COMMA; APPENDREG(0,REG1); DONE:=TRUE;
	 END;
      18:BEGIN DUMPEA(MODE1,REG1,EAX,OSIZE); DONE:=TRUE;
	 END;
      19:BEGIN DUMPEA(MODE1,REG1,EAX,0); DONE:=TRUE;
	 END;
      20:BEGIN DUMPEA(7,4,EAX,OSIZE); COMMA; OPC:=19;
	 END;
      21:BEGIN DUMPEA(MODE1,REG1,EAX,OSIZE); COMMA; APPENDREG(0,REG2);
	       DONE:=TRUE;
	 END;
      22:BEGIN APPENDREG(0,REG2); COMMA; OPC:=18;
	 END;
      23: { opcode $F }
	 begin
	 if reg2 = 1 then mc68881
	 { Next two lines JWH 12/24/89 : }
	 else if reg2 = 2 then cinv_cpush
	 else if (reg2 = 3) then move16
	 else
	   begin
	   s := '';
	   done := true;
	   end;
	 end;

      OTHERWISE         S :=''; DONE:=TRUE;
      END; { CASE OPC }
      UNTIL DONE;
    RECOVER
    BEGIN
      IF ESCAPECODE=0 THEN
	begin
	S := '';
	eax := original_eax; { advance 2 bytes for illegal instr }
	end
      {ELSE ESCAPE(ESCAPECODE)};
    END;
    NXTP := ORD(EAX);
  END;  { REVASM }

END.    { MODULE REVASM_MOD }

@


55.1
log
@Automatic bump of revision number for PWS version 3.25A
@
text
@@


54.1
log
@Automatic bump of revision number for PWS version 3.24
@
text
@@


53.1
log
@Automatic bump of revision number for PWS version 3.24B
@
text
@@


52.1
log
@Automatic bump of revision number for PWS version 3.24A
@
text
@@


51.1
log
@Automatic bump of revision number for PWS version 3.24d
@
text
@@


50.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


49.1
log
@Automatic bump of revision number for PWS version 3.24b
@
text
@@


48.1
log
@Automatic bump of revision number for PWS version 3.24a
@
text
@@


47.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


46.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


45.1
log
@Automatic bump of revision number for PWS version 3.23C
@
text
@@


44.1
log
@Automatic bump of revision number for PWS version 3.23B
@
text
@@


43.1
log
@Automatic bump of revision number for PWS version 3.23aA
@
text
@@


42.1
log
@Automatic bump of revision number for PWS version 3.23e
@
text
@@


41.6
log
@

        Minor change to move16 ... JWH 12/27/89.
@
text
@@


41.5
log
@

        Fixing syntax errors ... JWH 12/26/89.
@
text
@d1185 1
a1185 1
	2: (w : UWORD);
@


41.4
log
@

          Cleaning up move16 and cinv_cpush ... JWH 12/26/89.
@
text
@d1185 1
a1185 1
	2: (w : shortint);
d1204 1
a1204 1
	  if ((see_ex.nib2) <> 0 or (see_ex.byte_it <> 0)) then
@


41.3
log
@

             Tightened up the new move16 and cinv_cpush routines

             JWH 12/26/89.
@
text
@d1182 4
a1185 2
	  nib1,nib2 : 0..15;
	  byte_it : byte;
d1195 1
a1195 1
	if the_op <> 246 { $F6 } then escape(0); { First 8 bits }
d1203 1
a1203 1
	  see_ex := eax^.exoffword;
d1252 1
a1252 1
       if the_op <> 244 { $F4 } then escape(0); { First 8 bits }
@


41.2
log
@

           Added disassembly capability for the move16, cinv
       and cpush instructions. Also added disassembly capability
       for the new movec registers and the new explicitly
       forced single and double precision rounding mode floating
       point instructions.
@
text
@d1180 5
d1186 1
d1188 2
a1190 1
      see_it.w := INSR.INSTP^.IWORD;  { see it as a move16 }
d1193 2
d1198 1
a1198 1
	     escape(0); { begin defineword; goto 1; end; }
d1200 4
a1203 1
	     escape(0);   { ?????????????????????????? }
d1213 1
a1214 5
	    { 0 : begin emitpostincr(reg_ax); comma; extend(4,false,0); end;
	    1 : begin extend(4,false,0); comma; emitpostincr(reg_ax); end;
	    2 : begin emitardef(reg_ax); comma; extend(4,false,0); end;
	    3 : begin extend(4,false,0); comma; emitardef(reg_ax); end; }

d1247 1
d1250 1
d1252 1
a1252 1
	begin { CINV } { Check these out .... <<<============= }
d1254 1
a1254 1
	  0 : escape(0); { ILLEGAL ??? }
d1261 1
a1261 1
	  0 : escape(0); { ILLEGAL ??? }
d1275 1
a1275 1
	  0 : escape(0); { ILLEGAL ??? }
d1282 1
a1282 1
	  0 : escape(0); { ILLEGAL ??? }
d2091 1
a2091 1
	 else if ((reg2 = 3)) { and (instr.opmode = 0))} then move16
@


41.1
log
@Automatic bump of revision number for PWS version 3.23d
@
text
@d279 3
d287 5
d982 16
d1168 119
d2079 3
@


40.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


39.1
log
@Automatic bump of revision number for PWS version 3.23b
@
text
@@


38.1
log
@Automatic bump of revision number for PWS version 3.23a
@
text
@@


37.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


36.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


35.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


34.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


33.1
log
@Automatic bump of revision number for PWS version 3.22D
@
text
@@


32.1
log
@Automatic bump of revision number for PWS version 3.22C
@
text
@@


31.1
log
@Automatic bump of revision number for PWS version 3.22B
@
text
@@


30.1
log
@Automatic bump of revision number for PWS version 3.22A
@
text
@@


29.1
log
@Automatic bump of revision number for PWS version 3.22b
@
text
@@


28.1
log
@Automatic bump of revision number for PWS version 3.3b
@
text
@@


27.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


26.1
log
@Automatic bump of revision number for PWS version 3.3 Synch
@
text
@@


25.1
log
@Automatic bump of revision number for PWS version 3.2Y
@
text
@@


24.1
log
@Automatic bump of revision number for PWS version 3.2
@
text
@@


23.1
log
@Automatic bump of revision number for PWS version 3.2P
@
text
@@


22.1
log
@Automatic bump of revision number for PWS version 3.2N
@
text
@@


21.1
log
@Automatic bump of revision number for PWS version 3.2M
@
text
@@


20.1
log
@Automatic bump of revision number for PWS version 3.2L
@
text
@@


19.1
log
@Automatic bump of revision number for PWS version 3.2K
@
text
@@


18.1
log
@Automatic bump of revision number for PWS version 3.2J
@
text
@@


17.1
log
@Automatic bump of revision number for PWS version 3.2I+
@
text
@@


16.1
log
@Automatic bump of revision number for PWS version 3.2I
@
text
@@


15.1
log
@Automatic bump of revision number for PWS version 3.2H
@
text
@@


14.2
log
@changed "*SNEQ" to "*SNE" to match released 68881 manual
@
text
@@


14.1
log
@Automatic bump of revision number for PWS version 3.2G
@
text
@d776 1
a776 1
      30: s := s + 'SNEQ';
@


13.1
log
@Automatic bump of revision number for PWS version 3.2F
@
text
@@


12.1
log
@Automatic bump of revision number for PWS version 3.2E
@
text
@@


11.1
log
@Automatic bump of revision number for PWS version 3.2D
@
text
@@


10.1
log
@Automatic bump of revision number for PWS version 3.2C
@
text
@@


9.1
log
@Automatic bump of revision number for PWS version 3.2B
@
text
@@


8.2
log
@Added FINTRZ and changed FTcc and FTPcc to FTRAPcc.
@
text
@@


8.1
log
@Automatic bump of revision number for PWS version 3.2A
@
text
@d939 1
d1045 1
a1045 1
	     s := 'FT'
d1047 1
a1047 1
	     s := 'FTP'
@


7.2
log
@Fixes for 3.2A
@
text
@@


7.1
log
@Automatic bump of revision number for PWS version 3.2l
@
text
@d436 1
a436 1
		     strwrite(s,strlen(s)+1,i,x^.exoffword:1);
d443 1
a443 1
		     strwrite(s,strlen(s)+1,i,x^.exofflong:1);
@


6.1
log
@Automatic bump of revision number for PWS version 3.2k
@
text
@@


5.1
log
@Automatic bump of revision number for PWS version 3.2j
@
text
@@


4.1
log
@Automatic bump of revision number for PWS version 3.2i
@
text
@@


3.1
log
@Automatic bump of revision number for PWS version 3.2h
@
text
@@


2.1
log
@Auto bump rev number to 2.1 for sys 3.2e.
@
text
@@


1.1
log
@Initial revision
@
text
@@
