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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

42.1
date     90.01.23.17.29.27;  author jwh;  state Exp;
branches ;
next     41.4;

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

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

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

41.1
date     89.12.22.11.11.58;  author jwh;  state Exp;
branches ;
next     40.4;

40.4
date     89.12.21.15.27.25;  author jwh;  state Exp;
branches ;
next     40.3;

40.3
date     89.11.21.16.45.17;  author jwh;  state Exp;
branches ;
next     40.2;

40.2
date     89.11.21.11.10.40;  author jwh;  state Exp;
branches ;
next     40.1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

15.1
date     87.04.13.08.20.37;  author jws;  state Exp;
branches ;
next     14.1;

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

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

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

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

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

9.1
date     86.12.12.13.21.49;  author bayes;  state Exp;
branches ;
next     8.1;

8.1
date     86.11.27.11.02.52;  author jws;  state Exp;
branches ;
next     7.1;

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

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

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

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

3.1
date     86.09.01.11.15.19;  author hal;  state Exp;
branches ;
next     2.2;

2.2
date     86.08.26.11.20.31;  author geli;  state Exp;
branches ;
next     2.1;

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

1.1
date     86.06.30.12.57.55;  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
@{changes made by jch on 08/26/86}
{       make move and movea look the same}
{       register mask for movem}

PROCEDURE OUTPUTNOOP;   { OUTPUTS A NOP WORD WITH CURRENT LINE }
BEGIN
CODELENGTH:=2;
CODE.INT[1]:=20081;
IF NOT CONTIGUOUS THEN NEWCODESEG;
PUNCHWORD(20081);
LISTINST(1);
LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
END;

PROCEDURE ADDSANDSUBS; { KLUGE }
BEGIN
TRY
  LOCCTB:=LOCCTR;
  PARSEOPERAND(OPERAND1);
  LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND1.SIZE;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=5) THEN BEGIN
    ERROR(ERRBADMODE);
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
  END;
  IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  { JWH 12/26/89 : }
  { Force ADD to ADDA and SUB to SUBA when the destination
    register is an 'A' register : }
  if ((OPERAND2.MODE = 1) and (currop.name[4] = ' ')) then
     begin currop.name[5] := ' ';
	   currop.name[4] := 'A'; end;
  IF CURROP.NAME[4]=' ' THEN { ADD OR SUB }
    IF ((OPERAND1.MODE=0) OR (OPERAND2.MODE=0)) AND
      (MEMALT(OPERAND2) OR (OPERAND2.MODE=0)) THEN BEGIN
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK)
    END
    ELSE BEGIN
      { Changes 11/21/89 JWH }
      { Uncommented call to error, change escape to
	escape(BADOPS). This seems ??? to correct an error
	made by jch on 8/26/86 }
      {ERROR(ERRBADMODE);}              {move <-> movea}
      ERROR(ERRBADMODE);                { JWH 12/26/89 }
      ESCAPE(BADOPS);                   { JWH 12/26/89 }
      { ESCAPE(OPSOK); }                {jch  08/26/86}
    END
  ELSE BEGIN { ADDA OR SUBA }
    IF OPERAND2.MODE<>1 THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF SIZE=1 THEN BEGIN
      ERROR(ERRBADSIZE);
      SIZE:=2;
    END;
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK)
  END

RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.SIZE:=0;
    OPERAND2.REG:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
    LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
  CODEGEN;
  LISTINST(1);
  LOCCTR:=LOCCTB;
END;

PROCEDURE IMMEDINSTR;
VAR
  CMPI_PCREL: BOOLEAN;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF NOT((OPERAND1.MODE=7) AND (OPERAND1.REG=4)) THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  CMPI_PCREL:=(CURROP.NAME='CMPI     ') AND (OPERAND2.MODE=7) AND
    ((OPERAND2.REG=2) OR (OPERAND2.REG=3));
  IF ((CURROP.CLASS=18) AND NOT(DATALTERABLE(OPERAND2) OR CMPI_PCREL)) OR
     ((CURROP.CLASS=27) AND NOT(DATALTERABLE(OPERAND2) OR
				((OPERAND2.MODE=7) AND (OPERAND2.REG>4) and
				 (operand2.reg<7))))
       THEN BEGIN
       ERROR(ERRBADMODE);
       ESCAPE(BADOPS);
  END;
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG>=7) THEN BEGIN
     ERROR(ERRBADMODE); { FOUND USP, SFC, DFC, OR VBR }
     OPERAND2.REG:=6;   { LET CODEGEN THINK I FOUND SR }
  END;
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG>4) AND (SIZESUFFIX<>BLANK) THEN
    ERROR(ERRBADSUFFIX);
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG=5) THEN SIZE:=1;  { FORCE CCR SIZE }
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.VALUE.EXPREFS:=NIL;
    OPERAND1.VALUE.BASE:=ABSOLUT;
    IF SIZE=1 THEN OPERAND1.SIZE:=2 ELSE OPERAND1.SIZE:=SIZE;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE+OPERAND2.SIZE;
END;

PROCEDURE BITINSTR;
BEGIN
TRY
  LOCCTB.LONGINT := LOCCTR.LONGINT + 2;
  PARSEOPERAND(OPERAND1);
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  IF (OPERAND1.MODE<>0) AND (NOT((OPERAND1.MODE=7) AND (OPERAND1.REG=4)))
  THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=4) THEN
    LOCCTB.LONGINT := LOCCTB.LONGINT + 2;
  PARSEOPERAND(OPERAND2);
  IF CURROP.NAME='BTST     ' THEN BEGIN
    IF ( OPERAND2.MODE=1) OR
       ((OPERAND2.MODE=7) AND (OPERAND2.REG=4) AND (OPERAND1.MODE<>0)) OR
       ((OPERAND2.MODE=7) AND (OPERAND2.REG>4))
    THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND2.MODE:=0;
      OPERAND2.REG:=0;
      OPERAND2.SIZE:=0;
    END
  END
  ELSE IF NOT DATALTERABLE(OPERAND2) THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
    ERROR(ERRBADMODE);
    END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=4)
     and (operand1.value.exprefs=nil) THEN BEGIN
    IF (OPERAND2.MODE=0) THEN BEGIN
      IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF<=31)) THEN
	       ERROR(ERRFIELDOFLO)
     END
     ELSE IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	      (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	      (OPERAND1.VALUE.OFFSET.LOHALF<=7)) { CHANGE TO 7 LATER } THEN
		ERROR(ERRFIELDOFLO);
  END;
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
END;

PROCEDURE MOVEINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  IF CURROP.NAME='MOVEA    ' THEN BEGIN
    IF OPERAND2.MODE<>1 THEN ERROR(ERRBADMODE);
    IF (OPERAND1.MODE=7) AND (OPERAND1.REG>4) THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND1.MODE:=0; operand1.reg:=0;
    END;
    ESCAPE(OPSOK);
  END;
  IF DATALTERABLE(OPERAND2) THEN BEGIN  { MOST OF THE MOVES DO THIS }
    IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=7)  THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND1.MODE:=0; operand1.reg:=0;
    END;
    IF (OPERAND1.MODE=7) AND ((OPERAND1.REG=5) OR (OPERAND1.REG=6))
      AND (SIZESUFFIX<>' ') THEN  ERROR(ERRBADSUFFIX);
    ESCAPE(OPSOK);
  END;
  IF NOT((OPERAND1.MODE=7) AND (OPERAND1.REG>4)) AND (OPERAND2.MODE=1) THEN
    BEGIN
      {ERROR(ERRBADMODE);  { MOVE TO AN WITHOUT MOVEA } {jch 08/26/86}
      ESCAPE(OPSOK);
    END;
  if (operand2.mode=7) and (operand2.reg>=2) and
     (operand2.reg<=4) then begin
     error(errbadmode);
     escape(opsok);
  end;
  if ((operand1.mode=7) and (operand1.reg>7))  then begin
     error(errbadmode);
     operand1.reg:=6;   { let codegen think it is SR }
     escape(badops);
  end;
  if ((operand2.mode=7) and (operand2.reg>7)) then begin
     error(errbadmode);
     operand2.reg:=6;  { let codegen think it is SR }
     escape(badops);
  end;
  IF SIZESUFFIX<>' ' THEN ERROR(ERRBADSUFFIX);
  IF DATAMODE(OPERAND1) AND (OPERAND2.MODE=7) AND
     ((OPERAND2.REG=5) OR (OPERAND2.REG=6)) THEN ESCAPE(OPSOK);
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG=7) AND (OPERAND1.MODE=1)
    THEN ESCAPE(OPSOK);
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=7) AND (OPERAND2.MODE=1)
    THEN ESCAPE(OPSOK);
  ERROR(ERRBADMODE); { FOUND SOMETHING NOT TRAPPED ABOVE }
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT +
		   2+OPERAND1.SIZE+OPERAND2.SIZE;
END;

PROCEDURE DBCCINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF OPERAND1.MODE<>0 THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  EXPRESS(TRUE, EVALOK,EVALUE, CURCOL);
  EVALUE.OFFSET.LONGINT :=
      EVALUE.OFFSET.LONGINT - 2 - LOCCTR.LONGINT;
  OPERAND2.VALUE:=EVALUE;
  IF (EVALUE.EXPREFS=NIL) AND
    (NOT FITSIN16(EVALUE.OFFSET)) THEN ERROR(ERRFIELDOFLO);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
    OPERAND2.VALUE.OFFSET:=ZERO32;
    OPERAND2.VALUE.EXPREFS:=NIL;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
END;

PROCEDURE MOVEQINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  IF OPERAND2.MODE<>0 THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF OPERAND1.VALUE.EXPREFS<>NIL THEN ERROR(ERREXTREFS);
  IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
  if not((operand1.value.offset.longint>=-128) and
	 (operand1.value.offset.longint<=255)) then error(errfieldoflo);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK)
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.VALUE.BASE:=ABSOLUT;
    OPERAND1.VALUE.EXPREFS:=NIL;
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
END;


PROCEDURE MOVEMINSTR;

VAR DR: ( TOMEM, FROMMEM );
    MASK: WORD32;
    TEMP: WORD32;
    I: SHORTINT;
    IMMDATA : BOOLEAN;          {jch 08/26/86}

PROCEDURE FORMMASK;
{ASSUMES CHECKREGS HAS BEEN CALLED AND RETURNED TRUE }
VAR HOLDREGMODE: SYMKIND;
    HOLDREGNO: SHORTINT;
    I,J: SHORTINT;

PROCEDURE SETBITS;
BEGIN
  IF CHECKREGMODE=DREG THEN MASK.BITS[31-CHECKREGNO]:=TRUE
  ELSE MASK.BITS[23-CHECKREGNO]:=TRUE;
END;

BEGIN
  SETBITS;
  WHILE (LINE[CURCOL]='/') OR (LINE[CURCOL]='-') DO BEGIN
    IF LINE[CURCOL]='-' THEN BEGIN
      HOLDREGMODE:=CHECKREGMODE;
      HOLDREGNO:=CHECKREGNO;
      CURCOL:=CURCOL+1;
      IF NOT CHECKREGS THEN BEGIN
	ERROR(ERRREGEXP);
	ESCAPE(BADOPS);
$if not mc68881$
      END;
$end$
$if mc68881$
       end
      else if checkregmode = fpreg then
	begin error( errfpregnotallowed ); escape( badops ); end;
$end$
      IF (CHECKREGMODE<>HOLDREGMODE) OR (CHECKREGNO<HOLDREGNO) THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
      J:=CHECKREGNO;
      FOR I:=HOLDREGNO TO J  DO BEGIN
	CHECKREGNO:=I;
	SETBITS;
      END;
      IF NOT (LINE[CURCOL] IN ['/',' ',',']) THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
    END
    ELSE BEGIN
      CURCOL:=CURCOL+1;
      IF NOT CHECKREGS THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
      SETBITS;
    END; { OF IF }
  END;  { OF WHILE }
END; { OF PROCEDURE }

BEGIN
TRY
  MASK:=ZERO32;
  IMMDATA := FALSE;                                     {jch 08/26/86}
  IF (CHECKREGS OR (LINE[CURCOL] = '#')) THEN BEGIN     {jch 08/26/86}
    DR:=TOMEM;
$if mc68881$
    if ( checkregmode = fpreg ) then
      begin error( errfpregnotallowed ); escape( badops ); end;
$end$
    IF LINE[CURCOL] = '#' THEN BEGIN                    {jch 08/26/86}
	PARSEOPERAND(OPERAND1);                         {jch 08/26/86}
	OPERAND1.BD_SIZE := S_WORD;                     {jch 08/26/86}
	IMMDATA := TRUE;                                {jch 08/26/86}
	END                                             {jch 08/26/86}
    ELSE FORMMASK;                                      {jch 08/26/86}
    IF LINE[CURCOL]<>',' THEN BEGIN
      ERROR(ERRCOMMAEXP);
      ESCAPE(BADOPS);
    END;
    CURCOL:=CURCOL+1;
    PARSEOPERAND(OPERAND2);
    IF OPERAND2.MODE=4 THEN BEGIN
      IF NOT IMMDATA THEN                               {jch 08/26/86}
	FOR I:=0 TO 15 DO TEMP.BITS[31-I]:=MASK.BITS[16+I];
      MASK:=TEMP;
    END;
    IF (OPERAND2.MODE<>4) AND (NOT (CONTROLMODE(OPERAND2)
       AND ALTERABLE(OPERAND2))) THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK);
  END
  ELSE BEGIN
    DR:=FROMMEM;
    PARSEOPERAND(OPERAND1);
    IF (NOT CONTROLMODE(OPERAND1)) AND (OPERAND1.MODE<>3) THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF LINE[CURCOL]<>',' THEN BEGIN
      ERROR(ERRCOMMAEXP);
      ESCAPE(BADOPS);
    END;
    CURCOL:=CURCOL+1;
    IF NOT (CHECKREGS OR (LINE[CURCOL] = '#')) THEN BEGIN       {jch 08/26/86}
      ERROR(ERRREGEXP);
      ESCAPE(BADOPS);
$if not mc68881$
    END;
$end$
$if mc68881$
    end
    else if ( checkregmode = fpreg ) then
      begin error( errfpregnotallowed ); escape( badops ); end;
$end$
    IF LINE[CURCOL] = '#' THEN                                  {jch 08/26/86}
	BEGIN                                                   {jch 08/26/86}
	PARSEOPERAND(OPERAND2);                                 {jch 08/26/86}
	OPERAND2.BD_SIZE := S_WORD;                             {jch 08/26/86}
	IMMDATA := TRUE;                                        {jch 08/26/86}
	END                                                     {jch 08/26/86}
    ELSE FORMMASK;                                              {jch 08/26/86}
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK);
  END;
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND2.MODE:=3;
    OPERAND2.REG:=0;
    CODEGEN;
    LISTINST(1);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
  END
  ELSE IF ESCAPECODE=OPSOK THEN BEGIN
    IF DR=TOMEM THEN BEGIN
      OPERAND1.MODE:=7;
      OPERAND1.REG:=4;
      IF NOT IMMDATA THEN OPERAND1.VALUE.OFFSET:=MASK;          {jch 08/26/86}
      END
    ELSE BEGIN
      OPERAND2.MODE:=7;
      OPERAND2.REG:=4;
      IF NOT IMMDATA THEN OPERAND2.VALUE.OFFSET:=MASK;          {jch 08/26/86}
    END;
    CODEGEN;
    LISTINST(1);
    IF DR=TOMEM THEN
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4+OPERAND2.SIZE
    ELSE
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4+OPERAND1.SIZE;
  END
  ELSE ESCAPE(ESCAPECODE);
END;   { OF PROCEDURE MOVEMINSTR }


$include 'M68KPAS2C'$


BEGIN  { OF PASS2STUFF }
if currop.class = 99 then pass2pseudos
$if mc68881$
else
  if (currop.class >= fpbase) and (currop.class <= fptop) then
    pass2fpops
$end$
else CASE CURROP.CLASS OF

  0: { ILLEGAL OPCODE }
     BEGIN
       ERROR(ERRBADOP);
       OUTPUTNOOP;
     END;

  1,4: { ABCD, SBCD, ADDX, SUBX }
      BEGIN
	TRY
	  PARSEOPERAND(OPERAND1);
	  IF LINE[CURCOL]<>',' THEN BEGIN
	    ERROR(ERRCOMMAEXP);
	    ESCAPE(BADOPS);
	  END;
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND2);
	  IF (OPERAND1.MODE=OPERAND2.MODE) AND
	     ((OPERAND1.MODE=0) OR (OPERAND1.MODE=4)) THEN BEGIN
	       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	       ESCAPE(OPSOK)
	  END
	  ELSE BEGIN
	    ERROR(ERRBADMODE);
	    ESCAPE(BADOPS);
	  END;
	  ESCAPE(OPSOK);
	RECOVER
	  IF ESCAPECODE=BADOPS THEN BEGIN
	    OPERAND1.MODE:=0;
	    OPERAND2.MODE:=0;
	  END
	  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	  CODEGEN;
	  LISTINST(1);
	  LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  2: { ADD, ADDA, SUB, SUBA } ADDSANDSUBS;

 3: { ADDQ, SUBQ }
    BEGIN
    TRY
      LOCCTB:=LOCCTR;
      IF LINE[CURCOL]<>'#' THEN BEGIN
	ERROR(ERRBADMODE);
	operand1.value.offset:=zero32;
	escape(badops);
      END
      ELSE BEGIN
	PARSEOPERAND(OPERAND1);
	IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	  ERROR(ERREXTREFS);
	  OPERAND1.VALUE.EXPREFS:=NIL;
	END;
	IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
	IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	       (OPERAND1.VALUE.OFFSET.LOHALF>=1) AND
	       (OPERAND1.VALUE.OFFSET.LOHALF<=8)) THEN ERROR(ERRFIELDOFLO);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT ALTERABLE(OPERAND2) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END
	ELSE BEGIN
	  IF (SIZE=1) AND (OPERAND2.MODE=1) THEN
	    ERROR(ERRBADSIZE);
	  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	  ESCAPE(OPSOK)
	END
      END;
    ESCAPE(OPSOK);
    RECOVER
    BEGIN
      IF ESCAPECODE=BADOPS THEN BEGIN
	OPERAND2.MODE:=0;
	OPERAND2.REG:=0;
	OPERAND2.SIZE:=0;
      END
      ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND2.SIZE;
      CODEGEN;
      LISTINST(1);
      LOCCTR:=LOCCTB;
    END;
  END;

  5: {  AND, OR }
     BEGIN
     TRY
       LOCCTB:=LOCCTR;
       PARSEOPERAND(OPERAND1);
       LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND1.SIZE;
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF (OPERAND1.MODE<>0) AND (OPERAND2.MODE<>0) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF (NOT MEMALT(OPERAND2)) AND (OPERAND2.MODE<>0) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF NOT(MEMALT(OPERAND2)) AND NOT(DATAMODE(OPERAND1)) THEN
	 ERROR(ERRBADMODE)
       ELSE BEGIN
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 ESCAPE(OPSOK);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
	 OPERAND2.SIZE:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
       CODEGEN;
       LISTINST(1);
       LOCCTR:=LOCCTB;
     END;

   6: { ASL, ASR, ROL, ROR, ROXL, ROXR }
     BEGIN
     TRY
       LOCCTB.LONGINT := LOCCTR.LONGINT + 2;
       PARSEOPERAND(OPERAND1);
       IF MEMALT(OPERAND1) THEN BEGIN
	 IF (SIZE=1) OR (SIZE=4) THEN
	   ERROR(ERRBADSIZE);
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND1.SIZE;
	 ESCAPE(OPSOK);
       END;
       IF (OPERAND1.MODE=0) OR ((OPERAND1.MODE=7) AND (OPERAND1.REG=4))
       THEN BEGIN
	 IF LINE[CURCOL]<>',' THEN BEGIN
	   ERROR(ERRCOMMAEXP);
	   ESCAPE(BADOPS);
	 END;
	 CURCOL:=CURCOL+1;
	 PARSEOPERAND(OPERAND2);
	 IF (OPERAND2.MODE<>0) THEN BEGIN
	   ERROR(ERRBADMODE);
	   ESCAPE(BADOPS);
	 END;
	 IF OPERAND1.MODE=7 THEN BEGIN
	   IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
		  (OPERAND1.VALUE.OFFSET.LOHALF>=1) AND
		  (OPERAND1.VALUE.OFFSET.LOHALF<=8)) THEN BEGIN
		    ERROR(ERRFIELDOFLO);
		    ESCAPE(OPSOK);
	    END;
	    IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	      OPERAND1.VALUE.EXPREFS:=NIL;
	      ERROR(ERREXTREFS);
	      ESCAPE(OPSOK);
	    END;
	  END;
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 ESCAPE(OPSOK);
       END
       ELSE BEGIN
	 { STRANGE FIRST OP }
	 ERROR(ERRBADMODE);
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND1.SIZE:=0;
	 ESCAPE(BADOPS);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
	 OPERAND2.SIZE:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR:=LOCCTB;
     END;

   7: { Bcc, BSR }
     BEGIN
     TRY
       OPERAND1.SIZE:=1;
       EXPRESS(TRUE, EVALOK, EVALUE, CURCOL);
       EVALUE.OFFSET.LONGINT := EVALUE.OFFSET.LONGINT
				- 2 - LOCCTR.LONGINT;
       IF (SIZESUFFIX='S') OR (SIZESUFFIX='B') THEN
	 BEGIN
	 IF ( EVALUE.EXPREFS<>NIL) OR
	    ((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) or
	    ((evalue.base=relative) and (pcmode=abs)) THEN
	   BEGIN
	   ERROR(errbadexpr);
	   EVALUE.EXPREFS:=NIL;
	   ESCAPE(BADOPS);
	   END;
	 IF FITSIN8(EVALUE.OFFSET) AND NOT(EVALUE.OFFSET.LOHALF=0) THEN
	   ESCAPE(OPSOK)
	 ELSE (* NOT FITSIN8 *)
	   BEGIN
	   ERROR(ERRFIELDOFLO);
	   ESCAPE(BADOPS);
	   END (* NOT FITSIN8 *)
	 END (* SIZESUFFIX is short *)
       ELSE IF (SIZESUFFIX='W') THEN
	 BEGIN
	 if (evalue.exprefs=nil) and
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) and
	    not(fitsin16(evalue.offset)) then
	   error(errfieldoflo);
	 OPERAND1.SIZE:=2;
	 END
       ELSE IF (SIZESUFFIX='L') THEN
	 OPERAND1.SIZE:=4
       ELSE IF EVALOK=OK1 THEN
	 IF FITSIN8(EVALUE.OFFSET) AND
	    (EVALUE.EXPREFS=NIL) AND
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) THEN
	   ESCAPE(OPSOK)
	 ELSE (* NOT FITSIN8 *)
	   BEGIN
	   if (evalue.exprefs=nil) and
	      NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	      not((evalue.base=relative) and (pcmode=abs)) and
	      not(fitsin16(evalue.offset)) then
	     error(errfieldoflo);
	   OPERAND1.SIZE:=2;
	   ESCAPE(OPSOK);
	   END (* NOT FITSIN8 *)
       ELSE (* EVALOK<>OK1 *)
	 BEGIN
	 if (evalue.exprefs=nil) and
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) and
	    not(fitsin16(evalue.offset)) then
	   error(errfieldoflo);
	 OPERAND1.SIZE:=2;
	 ESCAPE(OPSOK);
	 END
     RECOVER
       BEGIN
       IF (ESCAPECODE<>BADOPS) AND (ESCAPECODE<>OPSOK) THEN
	 ESCAPE(ESCAPECODE);
       IF ESCAPECODE=OPSOK THEN
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       END;
     OPERAND1.VALUE:=EVALUE;
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2 + OPERAND1.SIZE;
     IF OPERAND1.SIZE=1 THEN LOCCTR.LONGINT:=LOCCTR.LONGINT-1;
     END;

   8: {BX  BIT OPERATIONS }
     BITINSTR;

   9,19: { DIVS, DIVU, MULS, MULU, CHK, LEA }
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF ((CURROP.CLASS= 9) AND (NOT    DATAMODE(OPERAND1))) OR
	  ((CURROP.CLASS=19) AND (NOT CONTROLMODE(OPERAND1)))  THEN
	 ERROR(ERRBADMODE);
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF ((CURROP.CLASS= 9) AND (OPERAND2.MODE<>0)) OR
	  ((CURROP.CLASS=19) AND (OPERAND2.MODE<>1))
	 THEN BEGIN
	   ERROR(ERRBADMODE);
	   ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       ESCAPE(OPSOK);
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 IF CURROP.CLASS=19 THEN OPERAND2.MODE:=1 ELSE OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
     END;

   10: { CLR }
      BEGIN
	PARSEOPERAND(OPERAND1);
	IF NOT (DATALTERABLE(OPERAND1) OR
		((CURROP.NAME='TST      ') AND
		 ((SIZESUFFIX<>'B') OR DATAMODE(OPERAND1))
		)
	       )
	   THEN ERROR(ERRBADMODE);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
      END;

   11: { CMP, CMPA }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=5) THEN BEGIN
	  ERROR(ERRBADMODE);
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	END;
	IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF ((OPERAND2.MODE<>0) AND (CURROP.NAME='CMP      ')) OR
	  ((OPERAND2.MODE<>1) AND (CURROP.NAME='CMPA     ')) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND2.MODE:=ORD(CURROP.NAME='CMPA     ');
	  OPERAND2.REG:=0;
	  OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
      END;


   12: BEGIN { STOP #XXXX ,  RTD  #XXXX }
	 PARSEOPERAND(OPERAND1);
	 IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
	   ERROR(ERRBADMODE);
	   OPERAND1.MODE:=7;
	   OPERAND1.REG:=4;
	   OPERAND1.VALUE.OFFSET:=ZERO32;
	   OPERAND1.VALUE.EXPREFS:=NIL;
	 END;
	 IF (OPERAND1.VALUE.EXPREFS=NIL)
	    AND  ((EVALUE.OFFSET.longint<-32768)
	     or (evalue.offset.longint>65535)) THEN
	   ERROR(ERRFIELDOFLO);
	 IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 CODEGEN;
	 LISTINST(1);
	 LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
       END;


   13: {DBCC }
      DBCCINSTR;

   14: { EOR }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF OPERAND1.MODE<>0 THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT DATALTERABLE(OPERAND2) THEN ERROR(ERRBADMODE);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG:=0;
	  OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND2.SIZE;
      END;

   15: { EXG }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) AND (OPERAND1.MODE<>1) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) AND (OPERAND2.MODE<>1) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF OPERAND1.MODE<>OPERAND2.MODE THEN
	  IF OPERAND2.MODE=0 THEN BEGIN
	    TOP:=OPERAND2;
	    OPERAND2:=OPERAND1;
	    OPERAND1:=TOP;
	  END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND1.REG:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  16: { EXT }
     BEGIN
     PARSEOPERAND(OPERAND1);
     IF OPERAND1.MODE<>0 THEN BEGIN
       ERROR(ERRBADMODE);
       OPERAND1.MODE:=0;
       OPERAND1.REG:=0;
     END;
     IF SIZE=1 THEN BEGIN
       ERROR(ERRBADSUFFIX);
       SIZE:=2;
     END;
     IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
     END;

  17: { JMP, JSR, PEA }
    BEGIN
    PARSEOPERAND(OPERAND1);
    IF NOT CONTROLMODE(OPERAND1) THEN ERROR(ERRBADMODE);
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    CODEGEN;
    LISTINST(1);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
    END;

  18,27: { ADDI, SUBI, CMPI, ANDI, ORI, EORI }
	 IMMEDINSTR;


  20: { LINK }
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF OPERAND1.MODE<>1 THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF NOT((OPERAND2.MODE=7) AND (OPERAND2.REG=4)) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       ESCAPE(OPSOK);
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND2.VALUE.OFFSET:=ZERO32;
	 OPERAND2.VALUE.BASE:=ABSOLUT;
	 OPERAND2.VALUE.EXPREFS:=NIL;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT +2 + SIZE;
     END;

  21: {MOVE, MOVEA }
     MOVEINSTR;


  22: {MOVEM}
      MOVEMINSTR;

  23: {MOVEP}
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF ((OPERAND1.MODE=0) AND (OPERAND2.MODE=5)) OR
	  ((OPERAND1.MODE=5) AND (OPERAND2.MODE=0)) THEN BEGIN
	   IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	    ESCAPE(OPSOK)
       END
       ELSE BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND2.MODE:=5;
	 OPERAND2.VALUE.OFFSET:=ZERO32;
	 OPERAND2.VALUE.EXPREFS:=NIL;
	 OPERAND2.VALUE.BASE:=ABSOLUT;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
     END;

  24: { MOVEQ }
     MOVEQINSTR;

  25: { SCC }
     BEGIN
     PARSEOPERAND(OPERAND1);
     IF NOT DATALTERABLE(OPERAND1) THEN ERROR(ERRBADMODE);
     IF LINE[CURCOL]<>' ' THEN ERROR(ERRBADSYNTAX);
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
     END;


  26: { NO OPERAND INSTRUCTIONS }
      BEGIN
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  28: {SWAP }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF OPERAND1.MODE<>0 THEN BEGIN
	OPERAND1.MODE:=0;
	OPERAND1.REG:=0;
	ERROR(ERRBADMODE);
      END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  29: { TRAP }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
	ERROR(ERRBADMODE);
	OPERAND1.VALUE.OFFSET:=ZERO32;
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.EXPREFS:=NIL;
      END;
      IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF<=15)) THEN
	       ERROR(ERRFIELDOFLO);
      IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	 OPERAND1.VALUE.EXPREFS:=NIL;
	 OPERAND1.VALUE.OFFSET:=ZERO32;
	 ERROR(ERREXTREFS);
      END;
      IF OPERAND1.VALUE.BASE<>ABSOLUT THEN
	BEGIN
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERRBADMODE);
	END;
      SIZE:=0;
      IF LINE[CURCOL]=',' THEN
	BEGIN
	SIZE:=2;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>7) OR (OPERAND2.REG<>4) THEN BEGIN
	  ERROR(ERRBADMODE);
	  OPERAND2.VALUE.OFFSET:=ZERO32;
	  OPERAND2.VALUE.BASE:=ABSOLUT;
	  OPERAND2.VALUE.EXPREFS:=NIL;
	IF OPERAND2.VALUE.BASE<>ABSOLUT THEN
	  BEGIN
	  OPERAND2.VALUE.BASE:=ABSOLUT;
	  OPERAND2.VALUE.OFFSET:=ZERO32;
	  ERROR(ERRBADMODE);
	  END;
      END;
	END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      IF SIZE=2
	THEN LOCCTR.LONGINT := LOCCTR.LONGINT + 4
	ELSE LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  30: { UNLK }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF OPERAND1.MODE<>1 THEN BEGIN
	OPERAND1.MODE:=1;
	OPERAND1.REG:=0;
	ERROR(ERRBADMODE);
      END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  31: { CMPM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND1.MODE<>3) OR (OPERAND2.MODE<>3) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=3;
	  OPERAND2.MODE:=3;
	  OPERAND1.REG:=0;
	  OPERAND2.REG:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  32: { MOVEC }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT((OPERAND1.MODE<=1) OR ((OPERAND1.MODE=7) AND
	       (OPERAND1.REG>=7))) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF ((OPERAND1.MODE<=1) AND NOT((OPERAND2.MODE=7) AND
	    (OPERAND2.REG>=7)))  OR  ((OPERAND1.MODE=7) AND
	    (OPERAND2.MODE>1)) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND2.MODE:=7;
	  OPERAND2.REG:=7;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT+4;
      END;

  33: { MOVES }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT(((OPERAND1.MODE<=1) OR (OPERAND2.MODE<=1)) AND
	       (MEMALT(OPERAND1) OR MEMALT(OPERAND2)))  THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0; OPERAND1.REG:=0;
	  OPERAND2.MODE:=2; OPERAND2.REG:=0;
	  OPERAND1.SIZE:=0; OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT + 4 + OPERAND1.SIZE +
	  OPERAND2.SIZE;
      END;

  34: { RTM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT(OPERAND1.MODE<=1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT+2;
      END;

  35: { BKPT }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	BEGIN
	ERROR(ERRBADMODE);
	OPERAND1.VALUE.OFFSET:=ZERO32;
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.EXPREFS:=NIL;
	END;
      IF NOT((OPERAND1.VALUE.OFFSET.LONGINT>=0) AND
	     (OPERAND1.VALUE.OFFSET.LONGINT<=7)) THEN
	       ERROR(ERRFIELDOFLO);
      IF OPERAND1.VALUE.EXPREFS<>NIL THEN
	BEGIN
	OPERAND1.VALUE.EXPREFS:=NIL;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERREXTREFS);
	END;
      IF OPERAND1.VALUE.BASE<>ABSOLUT THEN
	BEGIN
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERRBADMODE);
	END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  36: { TRAPcc }
      BEGIN
      TRY
	IF SIZESUFFIX=' ' THEN
	  BEGIN
	  SIZE:=0;
	  END
	ELSE
	  BEGIN
	  PARSEOPERAND(OPERAND1);
	  IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	    BEGIN
	    ERROR(ERRBADMODE);
	    ESCAPE(BADOPS);
	    END;
	  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	  END;
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.VALUE.OFFSET:=ZERO32;
	  OPERAND1.VALUE.BASE:=ABSOLUT;
	  OPERAND1.VALUE.EXPREFS:=NIL;
	  OPERAND1.MODE:=7;
	  OPERAND1.REG :=4;
	  END;
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2 + SIZE;
      END;

  37: { CALLM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF (0>OPERAND1.VALUE.OFFSET.LONGINT) OR
	   (OPERAND1.VALUE.OFFSET.LONGINT>=256) THEN
	  BEGIN ERROR(ERRFIELDOFLO); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT CONTROLMODE(OPERAND2) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=7;
	  OPERAND1.REG :=4;
	  OPERAND1.VALUE.OFFSET:=ZERO32;
	  OPERAND1.VALUE.EXPREFS:=NIL;
	  OPERAND1.VALUE.BASE:=ABSOLUT;
	  OPERAND1.SIZE:=1;
	  OPERAND2.MODE:=2;
	  OPERAND2.REG :=0;
	  OPERAND2.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND2.SIZE;
      END;

  38: { CAS }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF NOT MEMALT(OPERAND3) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=2;
	  OPERAND3.REG :=0;
	  OPERAND3.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND3.SIZE;
      END;

  39: { CAS2 }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF (OPERAND3.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND4);
	IF (OPERAND4.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND5);
	IF NOT (OPERAND5.MODE=2) AND            (* "(An)" *)
	   NOT ((OPERAND5.MODE=6) AND           (* "(Dn)" *)
		(OPERAND5.INDEXMODE=DATA) AND   (* also allows "(Dn.W*1)" *)
		(OPERAND5.INDEXSIZE=WRD ) AND
		(OPERAND5.INDEXSCALE=0  ) AND
		(OPERAND5.FULL_FORMAT)    AND
		(OPERAND5.BASE_SUPPRESS)  AND
		(NOT OPERAND5.INDEX_SUPPRESS) AND
		(OPERAND5.OD_SIZE=S_RES)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF OPERAND5.MODE=6 THEN
	  OPERAND5.REG:=OPERAND5.INDEX;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND6);
	IF NOT (OPERAND6.MODE=2) AND            (* "(An)" *)
	   NOT ((OPERAND6.MODE=6) AND           (* "(Dn)" *)
		(OPERAND6.INDEXMODE=DATA) AND   (* also allows "(Dn.W*1)" *)
		(OPERAND6.INDEXSIZE=WRD ) AND
		(OPERAND6.INDEXSCALE=0  ) AND
		(OPERAND6.FULL_FORMAT)    AND
		(OPERAND6.BASE_SUPPRESS)  AND
		(NOT OPERAND6.INDEX_SUPPRESS) AND
		(OPERAND6.OD_SIZE=S_RES)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF OPERAND6.MODE=6 THEN
	  OPERAND6.REG:=OPERAND6.INDEX;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  OPERAND4.MODE:=0;
	  OPERAND4.REG :=0;
	  OPERAND5.MODE:=2;
	  OPERAND5.REG :=0;
	  OPERAND6.MODE:=2;
	  OPERAND6.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 6;
      END;

  40: { CHK2, CMP2 }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT CONTROLMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE>1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=2;
	  OPERAND2.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  41: { PACK, UNPK }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND1.MODE<>OPERAND2.MODE) OR
	  ((OPERAND1.MODE<>0) AND (OPERAND1.MODE<>4)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF (OPERAND3.MODE<>7) OR (OPERAND3.REG<>4) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=7;
	  OPERAND3.REG :=4;
	  OPERAND3.VALUE.OFFSET:=ZERO32;
	  OPERAND3.VALUE.EXPREFS:=NIL;
	  OPERAND3.VALUE.BASE:=ABSOLUT;
	  OPERAND3.SIZE:=2;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
      END;

  42: { BFCHG, BFCLR, BFSET, BFTST }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT ((OPERAND1.MODE=0) OR
	  ((CURROP.NAME<>'BFTST    ') AND CONTROLALTERABLE(OPERAND1)) OR
	  ((CURROP.NAME ='BFTST    ') AND      CONTROLMODE(OPERAND1))) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	PARSE_BITFIELD(BITFIELD);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  43: { BFEXTS, BFEXTU, BFFFO }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) AND NOT CONTROLMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	PARSE_BITFIELD(BITFIELD);
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  44: { BFINS }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	PARSE_BITFIELD(BITFIELD);
	IF (OPERAND2.MODE<>0) AND NOT CONTROLALTERABLE(OPERAND2) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND2.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND2.SIZE;
      END;

  45: { DIV?.L, DIV?L.L, MUL?.L }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT DATAMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF OPERAND2.MODE<>0 THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]=':' THEN
	  BEGIN
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND3);
	  IF OPERAND3.MODE<>0 THEN
	    BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	  IF CURROP.NAME[5]='L' THEN (* must be DIV?L.L *)
	    OPERAND2.MODE:=1  (***** special flag for 32bit mode *****)
	  END
	ELSE
	  BEGIN
	  IF CURROP.NAME[5]='L' THEN (* must be DIV?L.L *)
	    BEGIN ERROR(ERRSYMBEXP);{*} ESCAPE(BADOPS); END;
	  OPERAND3:=OPERAND2;
	  OPERAND2.MODE:=1; (***** special flag for 32bit mode *****)
	  END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

    46: { MOVE16 - ADDED 6/30/89 JWH }
     BEGIN
      bump_value := 0;
      TRY
	PARSEOPERAND(OPERAND1);
	case operand1.MODE of
	 2: { (An) }
	   begin
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF OPERAND2.MODE <> 7 then { Oh Oh }
	      begin error(ERRBADMODE); escape(BADOPS); end
	    else
	     begin
	      bump_value := 2;
	      IF ((OPERAND2.VALUE.EXPREFS <> NIL) and
		  (OPERAND2.SIZE <> 4)) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     end;
	   end; { operand1.MODE = 2 }
	 3: { (An)+ }
	   begin
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF (OPERAND2.MODE <> 7) then { better be 3 }
	     BEGIN
	      IF (OPERAND2.MODE <> 3) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     END
	    ELSE { op2.mode = 7 }
	     begin
	      bump_value := 2;
	      IF ((OPERAND2.VALUE.EXPREFS <> NIL) and
		  (OPERAND2.SIZE <> 4)) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     end;
	   end; { operand1.MODE = 3 }
	 7: { Expr - absolute mode }
	   begin
	    bump_value := 2;
	    IF ((OPERAND1.VALUE.EXPREFS <> NIL) and
		(OPERAND1.SIZE <> 4)) then { Oh Oh }
	      begin error(ERRBADMODE); escape(BADOPS); end;
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF (OPERAND2.MODE <> 2) then { better be 3 }
	      IF (OPERAND2.MODE <> 3) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	   end; { operand1.MODE = 7 (absolute ) }
	 otherwise
	   begin error(ERRBADMODE); escape(BADOPS); end;
	end; { CASE OPERAND1.MODE OF }
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE := bump_value; { used by gencode }
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + bump_value;
      END;
  47,48,49,50,51,52: { CINVL,CINVP,CINVA,CPUSHL,CPUSHP,CPUSHA }
      BEGIN
      TRY
	OPERAND1.MODE := PARSE_CACHES;
	if OPERAND1.MODE = 0 then
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	if ((currop.CLASS = 49) or (currop.CLASS = 52)) THEN
		{ CINVA,CPUSHA  have no 2nd operand }
	  begin
	   if line[CURCOL] <> ' ' then
	    begin error(erreolexp); escape(badops); end;
	  end;
	if ((currop.CLASS <> 49) and (currop.CLASS <> 52)) THEN
		{ CINVA,CPUSHA  have no 2nd operand }
	 begin
	  IF LINE[CURCOL]<>',' THEN
	    BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND2);
	  if OPERAND2.MODE <> 2 then
	    BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	 end;
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

END; { OF CASE }
END;   { OF PASS2STUFF }



BEGIN
GETLINE;
WHILE (LINE<>' END') AND
      (CURROP.NAME<>'END      ') DO BEGIN
  IF ODD(LOCCTR.LOHALF) AND NOT((
     ( CURROP.NAME='DC       ') OR
     (CURROP.NAME='DS       ')) AND (SIZE=1))
     and (currop.name<>'         ') THEN BEGIN
    if contiguous then PUNCHBYTE(0);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 1;
  END;
  IF (LAB<>'') AND NOT((CURROP.CLASS=99)
	AND ((CURROP.CODE=5) OR (CURROP.CODE=13)
	      OR (CURROP.CODE=15))) THEN BEGIN
    LOOKUPSYMBOL(SP);
    IF NOT(SP^.EXT) AND ((SP^.SVALUE.LOHALF<>LOCCTR.LOHALF)
	 OR (SP^.SVALUE.HIHALF<>LOCCTR.HIHALF)) THEN ERROR(ERRPHASE);
  END;
  OPERAND1.VALUE.EXPREFS:=NIL;
  OPERAND2.VALUE.EXPREFS:=NIL;
  OPERAND3.VALUE.EXPREFS:=NIL;
  OPERAND4.VALUE.EXPREFS:=NIL;
  OPERAND5.VALUE.EXPREFS:=NIL;
  OPERAND6.VALUE.EXPREFS:=NIL;
  PASS2STUFF;
  IF OPERAND1.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND1.VALUE.EXPREFS);
  IF OPERAND2.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND2.VALUE.EXPREFS);
  IF OPERAND3.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND3.VALUE.EXPREFS);
  IF OPERAND4.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND4.VALUE.EXPREFS);
  IF OPERAND5.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND5.VALUE.EXPREFS);
  IF OPERAND6.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND6.VALUE.EXPREFS);
  IF ERRINLINE THEN BEGIN
    ERRINLINE:=FALSE;
    LISTERROR(LINEERRCODE);
  END;
  GETLINE;
END;
LISTINST(4);   { LIST END LINE }
END;


@


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


56.1
log
@Automatic bump of revision number for PWS version 3.25
@
text
@a0 1867
{changes made by jch on 08/26/86}
{       make move and movea look the same}
{       register mask for movem}

PROCEDURE OUTPUTNOOP;   { OUTPUTS A NOP WORD WITH CURRENT LINE }
BEGIN
CODELENGTH:=2;
CODE.INT[1]:=20081;
IF NOT CONTIGUOUS THEN NEWCODESEG;
PUNCHWORD(20081);
LISTINST(1);
LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
END;

PROCEDURE ADDSANDSUBS; { KLUGE }
BEGIN
TRY
  LOCCTB:=LOCCTR;
  PARSEOPERAND(OPERAND1);
  LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND1.SIZE;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=5) THEN BEGIN
    ERROR(ERRBADMODE);
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
  END;
  IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  { JWH 12/26/89 : }
  { Force ADD to ADDA and SUB to SUBA when the destination
    register is an 'A' register : }
  if ((OPERAND2.MODE = 1) and (currop.name[4] = ' ')) then
     begin currop.name[5] := ' ';
	   currop.name[4] := 'A'; end;
  IF CURROP.NAME[4]=' ' THEN { ADD OR SUB }
    IF ((OPERAND1.MODE=0) OR (OPERAND2.MODE=0)) AND
      (MEMALT(OPERAND2) OR (OPERAND2.MODE=0)) THEN BEGIN
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK)
    END
    ELSE BEGIN
      { Changes 11/21/89 JWH }
      { Uncommented call to error, change escape to
	escape(BADOPS). This seems ??? to correct an error
	made by jch on 8/26/86 }
      {ERROR(ERRBADMODE);}              {move <-> movea}
      ERROR(ERRBADMODE);                { JWH 12/26/89 }
      ESCAPE(BADOPS);                   { JWH 12/26/89 }
      { ESCAPE(OPSOK); }                {jch  08/26/86}
    END
  ELSE BEGIN { ADDA OR SUBA }
    IF OPERAND2.MODE<>1 THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF SIZE=1 THEN BEGIN
      ERROR(ERRBADSIZE);
      SIZE:=2;
    END;
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK)
  END

RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.SIZE:=0;
    OPERAND2.REG:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
    LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
  CODEGEN;
  LISTINST(1);
  LOCCTR:=LOCCTB;
END;

PROCEDURE IMMEDINSTR;
VAR
  CMPI_PCREL: BOOLEAN;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF NOT((OPERAND1.MODE=7) AND (OPERAND1.REG=4)) THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  CMPI_PCREL:=(CURROP.NAME='CMPI     ') AND (OPERAND2.MODE=7) AND
    ((OPERAND2.REG=2) OR (OPERAND2.REG=3));
  IF ((CURROP.CLASS=18) AND NOT(DATALTERABLE(OPERAND2) OR CMPI_PCREL)) OR
     ((CURROP.CLASS=27) AND NOT(DATALTERABLE(OPERAND2) OR
				((OPERAND2.MODE=7) AND (OPERAND2.REG>4) and
				 (operand2.reg<7))))
       THEN BEGIN
       ERROR(ERRBADMODE);
       ESCAPE(BADOPS);
  END;
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG>=7) THEN BEGIN
     ERROR(ERRBADMODE); { FOUND USP, SFC, DFC, OR VBR }
     OPERAND2.REG:=6;   { LET CODEGEN THINK I FOUND SR }
  END;
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG>4) AND (SIZESUFFIX<>BLANK) THEN
    ERROR(ERRBADSUFFIX);
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG=5) THEN SIZE:=1;  { FORCE CCR SIZE }
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.VALUE.EXPREFS:=NIL;
    OPERAND1.VALUE.BASE:=ABSOLUT;
    IF SIZE=1 THEN OPERAND1.SIZE:=2 ELSE OPERAND1.SIZE:=SIZE;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE+OPERAND2.SIZE;
END;

PROCEDURE BITINSTR;
BEGIN
TRY
  LOCCTB.LONGINT := LOCCTR.LONGINT + 2;
  PARSEOPERAND(OPERAND1);
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  IF (OPERAND1.MODE<>0) AND (NOT((OPERAND1.MODE=7) AND (OPERAND1.REG=4)))
  THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=4) THEN
    LOCCTB.LONGINT := LOCCTB.LONGINT + 2;
  PARSEOPERAND(OPERAND2);
  IF CURROP.NAME='BTST     ' THEN BEGIN
    IF ( OPERAND2.MODE=1) OR
       ((OPERAND2.MODE=7) AND (OPERAND2.REG=4) AND (OPERAND1.MODE<>0)) OR
       ((OPERAND2.MODE=7) AND (OPERAND2.REG>4))
    THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND2.MODE:=0;
      OPERAND2.REG:=0;
      OPERAND2.SIZE:=0;
    END
  END
  ELSE IF NOT DATALTERABLE(OPERAND2) THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
    ERROR(ERRBADMODE);
    END;
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=4)
     and (operand1.value.exprefs=nil) THEN BEGIN
    IF (OPERAND2.MODE=0) THEN BEGIN
      IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF<=31)) THEN
	       ERROR(ERRFIELDOFLO)
     END
     ELSE IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	      (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	      (OPERAND1.VALUE.OFFSET.LOHALF<=7)) { CHANGE TO 7 LATER } THEN
		ERROR(ERRFIELDOFLO);
  END;
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
END;

PROCEDURE MOVEINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  IF CURROP.NAME='MOVEA    ' THEN BEGIN
    IF OPERAND2.MODE<>1 THEN ERROR(ERRBADMODE);
    IF (OPERAND1.MODE=7) AND (OPERAND1.REG>4) THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND1.MODE:=0; operand1.reg:=0;
    END;
    ESCAPE(OPSOK);
  END;
  IF DATALTERABLE(OPERAND2) THEN BEGIN  { MOST OF THE MOVES DO THIS }
    IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=7)  THEN BEGIN
      ERROR(ERRBADMODE);
      OPERAND1.MODE:=0; operand1.reg:=0;
    END;
    IF (OPERAND1.MODE=7) AND ((OPERAND1.REG=5) OR (OPERAND1.REG=6))
      AND (SIZESUFFIX<>' ') THEN  ERROR(ERRBADSUFFIX);
    ESCAPE(OPSOK);
  END;
  IF NOT((OPERAND1.MODE=7) AND (OPERAND1.REG>4)) AND (OPERAND2.MODE=1) THEN
    BEGIN
      {ERROR(ERRBADMODE);  { MOVE TO AN WITHOUT MOVEA } {jch 08/26/86}
      ESCAPE(OPSOK);
    END;
  if (operand2.mode=7) and (operand2.reg>=2) and
     (operand2.reg<=4) then begin
     error(errbadmode);
     escape(opsok);
  end;
  if ((operand1.mode=7) and (operand1.reg>7))  then begin
     error(errbadmode);
     operand1.reg:=6;   { let codegen think it is SR }
     escape(badops);
  end;
  if ((operand2.mode=7) and (operand2.reg>7)) then begin
     error(errbadmode);
     operand2.reg:=6;  { let codegen think it is SR }
     escape(badops);
  end;
  IF SIZESUFFIX<>' ' THEN ERROR(ERRBADSUFFIX);
  IF DATAMODE(OPERAND1) AND (OPERAND2.MODE=7) AND
     ((OPERAND2.REG=5) OR (OPERAND2.REG=6)) THEN ESCAPE(OPSOK);
  IF (OPERAND2.MODE=7) AND (OPERAND2.REG=7) AND (OPERAND1.MODE=1)
    THEN ESCAPE(OPSOK);
  IF (OPERAND1.MODE=7) AND (OPERAND1.REG=7) AND (OPERAND2.MODE=1)
    THEN ESCAPE(OPSOK);
  ERROR(ERRBADMODE); { FOUND SOMETHING NOT TRAPPED ABOVE }
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
    OPERAND2.SIZE:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT +
		   2+OPERAND1.SIZE+OPERAND2.SIZE;
END;

PROCEDURE DBCCINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF OPERAND1.MODE<>0 THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  EXPRESS(TRUE, EVALOK,EVALUE, CURCOL);
  EVALUE.OFFSET.LONGINT :=
      EVALUE.OFFSET.LONGINT - 2 - LOCCTR.LONGINT;
  OPERAND2.VALUE:=EVALUE;
  IF (EVALUE.EXPREFS=NIL) AND
    (NOT FITSIN16(EVALUE.OFFSET)) THEN ERROR(ERRFIELDOFLO);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK);
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.MODE:=0;
    OPERAND1.REG:=0;
    OPERAND2.VALUE.OFFSET:=ZERO32;
    OPERAND2.VALUE.EXPREFS:=NIL;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
END;

PROCEDURE MOVEQINSTR;
BEGIN
TRY
  PARSEOPERAND(OPERAND1);
  IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF LINE[CURCOL]<>',' THEN BEGIN
    ERROR(ERRCOMMAEXP);
    ESCAPE(BADOPS);
  END;
  CURCOL:=CURCOL+1;
  PARSEOPERAND(OPERAND2);
  IF OPERAND2.MODE<>0 THEN BEGIN
    ERROR(ERRBADMODE);
    ESCAPE(BADOPS);
  END;
  IF OPERAND1.VALUE.EXPREFS<>NIL THEN ERROR(ERREXTREFS);
  IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
  if not((operand1.value.offset.longint>=-128) and
	 (operand1.value.offset.longint<=255)) then error(errfieldoflo);
  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
  ESCAPE(OPSOK)
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.VALUE.BASE:=ABSOLUT;
    OPERAND1.VALUE.EXPREFS:=NIL;
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND2.MODE:=0;
    OPERAND2.REG:=0;
  END
  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
  CODEGEN;
  LISTINST(1);
  LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
END;


PROCEDURE MOVEMINSTR;

VAR DR: ( TOMEM, FROMMEM );
    MASK: WORD32;
    TEMP: WORD32;
    I: SHORTINT;
    IMMDATA : BOOLEAN;          {jch 08/26/86}

PROCEDURE FORMMASK;
{ASSUMES CHECKREGS HAS BEEN CALLED AND RETURNED TRUE }
VAR HOLDREGMODE: SYMKIND;
    HOLDREGNO: SHORTINT;
    I,J: SHORTINT;

PROCEDURE SETBITS;
BEGIN
  IF CHECKREGMODE=DREG THEN MASK.BITS[31-CHECKREGNO]:=TRUE
  ELSE MASK.BITS[23-CHECKREGNO]:=TRUE;
END;

BEGIN
  SETBITS;
  WHILE (LINE[CURCOL]='/') OR (LINE[CURCOL]='-') DO BEGIN
    IF LINE[CURCOL]='-' THEN BEGIN
      HOLDREGMODE:=CHECKREGMODE;
      HOLDREGNO:=CHECKREGNO;
      CURCOL:=CURCOL+1;
      IF NOT CHECKREGS THEN BEGIN
	ERROR(ERRREGEXP);
	ESCAPE(BADOPS);
$if not mc68881$
      END;
$end$
$if mc68881$
       end
      else if checkregmode = fpreg then
	begin error( errfpregnotallowed ); escape( badops ); end;
$end$
      IF (CHECKREGMODE<>HOLDREGMODE) OR (CHECKREGNO<HOLDREGNO) THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
      J:=CHECKREGNO;
      FOR I:=HOLDREGNO TO J  DO BEGIN
	CHECKREGNO:=I;
	SETBITS;
      END;
      IF NOT (LINE[CURCOL] IN ['/',' ',',']) THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
    END
    ELSE BEGIN
      CURCOL:=CURCOL+1;
      IF NOT CHECKREGS THEN BEGIN
	ERROR(ERRBADSYNTAX);
	ESCAPE(BADOPS);
      END;
      SETBITS;
    END; { OF IF }
  END;  { OF WHILE }
END; { OF PROCEDURE }

BEGIN
TRY
  MASK:=ZERO32;
  IMMDATA := FALSE;                                     {jch 08/26/86}
  IF (CHECKREGS OR (LINE[CURCOL] = '#')) THEN BEGIN     {jch 08/26/86}
    DR:=TOMEM;
$if mc68881$
    if ( checkregmode = fpreg ) then
      begin error( errfpregnotallowed ); escape( badops ); end;
$end$
    IF LINE[CURCOL] = '#' THEN BEGIN                    {jch 08/26/86}
	PARSEOPERAND(OPERAND1);                         {jch 08/26/86}
	OPERAND1.BD_SIZE := S_WORD;                     {jch 08/26/86}
	IMMDATA := TRUE;                                {jch 08/26/86}
	END                                             {jch 08/26/86}
    ELSE FORMMASK;                                      {jch 08/26/86}
    IF LINE[CURCOL]<>',' THEN BEGIN
      ERROR(ERRCOMMAEXP);
      ESCAPE(BADOPS);
    END;
    CURCOL:=CURCOL+1;
    PARSEOPERAND(OPERAND2);
    IF OPERAND2.MODE=4 THEN BEGIN
      IF NOT IMMDATA THEN                               {jch 08/26/86}
	FOR I:=0 TO 15 DO TEMP.BITS[31-I]:=MASK.BITS[16+I];
      MASK:=TEMP;
    END;
    IF (OPERAND2.MODE<>4) AND (NOT (CONTROLMODE(OPERAND2)
       AND ALTERABLE(OPERAND2))) THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK);
  END
  ELSE BEGIN
    DR:=FROMMEM;
    PARSEOPERAND(OPERAND1);
    IF (NOT CONTROLMODE(OPERAND1)) AND (OPERAND1.MODE<>3) THEN BEGIN
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
    END;
    IF LINE[CURCOL]<>',' THEN BEGIN
      ERROR(ERRCOMMAEXP);
      ESCAPE(BADOPS);
    END;
    CURCOL:=CURCOL+1;
    IF NOT (CHECKREGS OR (LINE[CURCOL] = '#')) THEN BEGIN       {jch 08/26/86}
      ERROR(ERRREGEXP);
      ESCAPE(BADOPS);
$if not mc68881$
    END;
$end$
$if mc68881$
    end
    else if ( checkregmode = fpreg ) then
      begin error( errfpregnotallowed ); escape( badops ); end;
$end$
    IF LINE[CURCOL] = '#' THEN                                  {jch 08/26/86}
	BEGIN                                                   {jch 08/26/86}
	PARSEOPERAND(OPERAND2);                                 {jch 08/26/86}
	OPERAND2.BD_SIZE := S_WORD;                             {jch 08/26/86}
	IMMDATA := TRUE;                                        {jch 08/26/86}
	END                                                     {jch 08/26/86}
    ELSE FORMMASK;                                              {jch 08/26/86}
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    ESCAPE(OPSOK);
  END;
RECOVER
  IF ESCAPECODE=BADOPS THEN BEGIN
    OPERAND1.VALUE.OFFSET:=ZERO32;
    OPERAND1.MODE:=7;
    OPERAND1.REG:=4;
    OPERAND2.MODE:=3;
    OPERAND2.REG:=0;
    CODEGEN;
    LISTINST(1);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
  END
  ELSE IF ESCAPECODE=OPSOK THEN BEGIN
    IF DR=TOMEM THEN BEGIN
      OPERAND1.MODE:=7;
      OPERAND1.REG:=4;
      IF NOT IMMDATA THEN OPERAND1.VALUE.OFFSET:=MASK;          {jch 08/26/86}
      END
    ELSE BEGIN
      OPERAND2.MODE:=7;
      OPERAND2.REG:=4;
      IF NOT IMMDATA THEN OPERAND2.VALUE.OFFSET:=MASK;          {jch 08/26/86}
    END;
    CODEGEN;
    LISTINST(1);
    IF DR=TOMEM THEN
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4+OPERAND2.SIZE
    ELSE
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4+OPERAND1.SIZE;
  END
  ELSE ESCAPE(ESCAPECODE);
END;   { OF PROCEDURE MOVEMINSTR }


$include 'M68KPAS2C'$


BEGIN  { OF PASS2STUFF }
if currop.class = 99 then pass2pseudos
$if mc68881$
else
  if (currop.class >= fpbase) and (currop.class <= fptop) then
    pass2fpops
$end$
else CASE CURROP.CLASS OF

  0: { ILLEGAL OPCODE }
     BEGIN
       ERROR(ERRBADOP);
       OUTPUTNOOP;
     END;

  1,4: { ABCD, SBCD, ADDX, SUBX }
      BEGIN
	TRY
	  PARSEOPERAND(OPERAND1);
	  IF LINE[CURCOL]<>',' THEN BEGIN
	    ERROR(ERRCOMMAEXP);
	    ESCAPE(BADOPS);
	  END;
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND2);
	  IF (OPERAND1.MODE=OPERAND2.MODE) AND
	     ((OPERAND1.MODE=0) OR (OPERAND1.MODE=4)) THEN BEGIN
	       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	       ESCAPE(OPSOK)
	  END
	  ELSE BEGIN
	    ERROR(ERRBADMODE);
	    ESCAPE(BADOPS);
	  END;
	  ESCAPE(OPSOK);
	RECOVER
	  IF ESCAPECODE=BADOPS THEN BEGIN
	    OPERAND1.MODE:=0;
	    OPERAND2.MODE:=0;
	  END
	  ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	  CODEGEN;
	  LISTINST(1);
	  LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  2: { ADD, ADDA, SUB, SUBA } ADDSANDSUBS;

 3: { ADDQ, SUBQ }
    BEGIN
    TRY
      LOCCTB:=LOCCTR;
      IF LINE[CURCOL]<>'#' THEN BEGIN
	ERROR(ERRBADMODE);
	operand1.value.offset:=zero32;
	escape(badops);
      END
      ELSE BEGIN
	PARSEOPERAND(OPERAND1);
	IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	  ERROR(ERREXTREFS);
	  OPERAND1.VALUE.EXPREFS:=NIL;
	END;
	IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
	IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	       (OPERAND1.VALUE.OFFSET.LOHALF>=1) AND
	       (OPERAND1.VALUE.OFFSET.LOHALF<=8)) THEN ERROR(ERRFIELDOFLO);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT ALTERABLE(OPERAND2) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END
	ELSE BEGIN
	  IF (SIZE=1) AND (OPERAND2.MODE=1) THEN
	    ERROR(ERRBADSIZE);
	  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	  ESCAPE(OPSOK)
	END
      END;
    ESCAPE(OPSOK);
    RECOVER
    BEGIN
      IF ESCAPECODE=BADOPS THEN BEGIN
	OPERAND2.MODE:=0;
	OPERAND2.REG:=0;
	OPERAND2.SIZE:=0;
      END
      ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND2.SIZE;
      CODEGEN;
      LISTINST(1);
      LOCCTR:=LOCCTB;
    END;
  END;

  5: {  AND, OR }
     BEGIN
     TRY
       LOCCTB:=LOCCTR;
       PARSEOPERAND(OPERAND1);
       LOCCTB.LONGINT := LOCCTB.LONGINT + 2+OPERAND1.SIZE;
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF (OPERAND1.MODE<>0) AND (OPERAND2.MODE<>0) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF (NOT MEMALT(OPERAND2)) AND (OPERAND2.MODE<>0) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF NOT(MEMALT(OPERAND2)) AND NOT(DATAMODE(OPERAND1)) THEN
	 ERROR(ERRBADMODE)
       ELSE BEGIN
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 ESCAPE(OPSOK);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
	 OPERAND2.SIZE:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND2.SIZE;
       CODEGEN;
       LISTINST(1);
       LOCCTR:=LOCCTB;
     END;

   6: { ASL, ASR, ROL, ROR, ROXL, ROXR }
     BEGIN
     TRY
       LOCCTB.LONGINT := LOCCTR.LONGINT + 2;
       PARSEOPERAND(OPERAND1);
       IF MEMALT(OPERAND1) THEN BEGIN
	 IF (SIZE=1) OR (SIZE=4) THEN
	   ERROR(ERRBADSIZE);
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 LOCCTB.LONGINT := LOCCTB.LONGINT + OPERAND1.SIZE;
	 ESCAPE(OPSOK);
       END;
       IF (OPERAND1.MODE=0) OR ((OPERAND1.MODE=7) AND (OPERAND1.REG=4))
       THEN BEGIN
	 IF LINE[CURCOL]<>',' THEN BEGIN
	   ERROR(ERRCOMMAEXP);
	   ESCAPE(BADOPS);
	 END;
	 CURCOL:=CURCOL+1;
	 PARSEOPERAND(OPERAND2);
	 IF (OPERAND2.MODE<>0) THEN BEGIN
	   ERROR(ERRBADMODE);
	   ESCAPE(BADOPS);
	 END;
	 IF OPERAND1.MODE=7 THEN BEGIN
	   IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
		  (OPERAND1.VALUE.OFFSET.LOHALF>=1) AND
		  (OPERAND1.VALUE.OFFSET.LOHALF<=8)) THEN BEGIN
		    ERROR(ERRFIELDOFLO);
		    ESCAPE(OPSOK);
	    END;
	    IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	      OPERAND1.VALUE.EXPREFS:=NIL;
	      ERROR(ERREXTREFS);
	      ESCAPE(OPSOK);
	    END;
	  END;
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 ESCAPE(OPSOK);
       END
       ELSE BEGIN
	 { STRANGE FIRST OP }
	 ERROR(ERRBADMODE);
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND1.SIZE:=0;
	 ESCAPE(BADOPS);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
	 OPERAND2.SIZE:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR:=LOCCTB;
     END;

   7: { Bcc, BSR }
     BEGIN
     TRY
       OPERAND1.SIZE:=1;
       EXPRESS(TRUE, EVALOK, EVALUE, CURCOL);
       EVALUE.OFFSET.LONGINT := EVALUE.OFFSET.LONGINT
				- 2 - LOCCTR.LONGINT;
       IF (SIZESUFFIX='S') OR (SIZESUFFIX='B') THEN
	 BEGIN
	 IF ( EVALUE.EXPREFS<>NIL) OR
	    ((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) or
	    ((evalue.base=relative) and (pcmode=abs)) THEN
	   BEGIN
	   ERROR(errbadexpr);
	   EVALUE.EXPREFS:=NIL;
	   ESCAPE(BADOPS);
	   END;
	 IF FITSIN8(EVALUE.OFFSET) AND NOT(EVALUE.OFFSET.LOHALF=0) THEN
	   ESCAPE(OPSOK)
	 ELSE (* NOT FITSIN8 *)
	   BEGIN
	   ERROR(ERRFIELDOFLO);
	   ESCAPE(BADOPS);
	   END (* NOT FITSIN8 *)
	 END (* SIZESUFFIX is short *)
       ELSE IF (SIZESUFFIX='W') THEN
	 BEGIN
	 if (evalue.exprefs=nil) and
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) and
	    not(fitsin16(evalue.offset)) then
	   error(errfieldoflo);
	 OPERAND1.SIZE:=2;
	 END
       ELSE IF (SIZESUFFIX='L') THEN
	 OPERAND1.SIZE:=4
       ELSE IF EVALOK=OK1 THEN
	 IF FITSIN8(EVALUE.OFFSET) AND
	    (EVALUE.EXPREFS=NIL) AND
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) THEN
	   ESCAPE(OPSOK)
	 ELSE (* NOT FITSIN8 *)
	   BEGIN
	   if (evalue.exprefs=nil) and
	      NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	      not((evalue.base=relative) and (pcmode=abs)) and
	      not(fitsin16(evalue.offset)) then
	     error(errfieldoflo);
	   OPERAND1.SIZE:=2;
	   ESCAPE(OPSOK);
	   END (* NOT FITSIN8 *)
       ELSE (* EVALOK<>OK1 *)
	 BEGIN
	 if (evalue.exprefs=nil) and
	    NOT((EVALUE.BASE=ABSOLUT ) AND (PCMODE=REL)) and
	    not((evalue.base=relative) and (pcmode=abs)) and
	    not(fitsin16(evalue.offset)) then
	   error(errfieldoflo);
	 OPERAND1.SIZE:=2;
	 ESCAPE(OPSOK);
	 END
     RECOVER
       BEGIN
       IF (ESCAPECODE<>BADOPS) AND (ESCAPECODE<>OPSOK) THEN
	 ESCAPE(ESCAPECODE);
       IF ESCAPECODE=OPSOK THEN
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       END;
     OPERAND1.VALUE:=EVALUE;
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2 + OPERAND1.SIZE;
     IF OPERAND1.SIZE=1 THEN LOCCTR.LONGINT:=LOCCTR.LONGINT-1;
     END;

   8: {BX  BIT OPERATIONS }
     BITINSTR;

   9,19: { DIVS, DIVU, MULS, MULU, CHK, LEA }
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF ((CURROP.CLASS= 9) AND (NOT    DATAMODE(OPERAND1))) OR
	  ((CURROP.CLASS=19) AND (NOT CONTROLMODE(OPERAND1)))  THEN
	 ERROR(ERRBADMODE);
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF ((CURROP.CLASS= 9) AND (OPERAND2.MODE<>0)) OR
	  ((CURROP.CLASS=19) AND (OPERAND2.MODE<>1))
	 THEN BEGIN
	   ERROR(ERRBADMODE);
	   ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       ESCAPE(OPSOK);
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 IF CURROP.CLASS=19 THEN OPERAND2.MODE:=1 ELSE OPERAND2.MODE:=0;
	 OPERAND2.REG:=0;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
     END;

   10: { CLR }
      BEGIN
	PARSEOPERAND(OPERAND1);
	IF NOT (DATALTERABLE(OPERAND1) OR
		((CURROP.NAME='TST      ') AND
		 ((SIZESUFFIX<>'B') OR DATAMODE(OPERAND1))
		)
	       )
	   THEN ERROR(ERRBADMODE);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
      END;

   11: { CMP, CMPA }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	IF (OPERAND1.MODE=7) AND (OPERAND1.REG>=5) THEN BEGIN
	  ERROR(ERRBADMODE);
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	END;
	IF (SIZE=1) AND (OPERAND1.MODE=1) THEN ERROR(ERRBADSUFFIX);
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF ((OPERAND2.MODE<>0) AND (CURROP.NAME='CMP      ')) OR
	  ((OPERAND2.MODE<>1) AND (CURROP.NAME='CMPA     ')) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND2.MODE:=ORD(CURROP.NAME='CMPA     ');
	  OPERAND2.REG:=0;
	  OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
      END;


   12: BEGIN { STOP #XXXX ,  RTD  #XXXX }
	 PARSEOPERAND(OPERAND1);
	 IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
	   ERROR(ERRBADMODE);
	   OPERAND1.MODE:=7;
	   OPERAND1.REG:=4;
	   OPERAND1.VALUE.OFFSET:=ZERO32;
	   OPERAND1.VALUE.EXPREFS:=NIL;
	 END;
	 IF (OPERAND1.VALUE.EXPREFS=NIL)
	    AND  ((EVALUE.OFFSET.longint<-32768)
	     or (evalue.offset.longint>65535)) THEN
	   ERROR(ERRFIELDOFLO);
	 IF OPERAND1.VALUE.BASE<>ABSOLUT THEN ERROR(ERRBADBASE);
	 IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	 CODEGEN;
	 LISTINST(1);
	 LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
       END;


   13: {DBCC }
      DBCCINSTR;

   14: { EOR }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF OPERAND1.MODE<>0 THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT DATALTERABLE(OPERAND2) THEN ERROR(ERRBADMODE);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG:=0;
	  OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND2.SIZE;
      END;

   15: { EXG }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) AND (OPERAND1.MODE<>1) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) AND (OPERAND2.MODE<>1) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF OPERAND1.MODE<>OPERAND2.MODE THEN
	  IF OPERAND2.MODE=0 THEN BEGIN
	    TOP:=OPERAND2;
	    OPERAND2:=OPERAND1;
	    OPERAND1:=TOP;
	  END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND1.REG:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  16: { EXT }
     BEGIN
     PARSEOPERAND(OPERAND1);
     IF OPERAND1.MODE<>0 THEN BEGIN
       ERROR(ERRBADMODE);
       OPERAND1.MODE:=0;
       OPERAND1.REG:=0;
     END;
     IF SIZE=1 THEN BEGIN
       ERROR(ERRBADSUFFIX);
       SIZE:=2;
     END;
     IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
     END;

  17: { JMP, JSR, PEA }
    BEGIN
    PARSEOPERAND(OPERAND1);
    IF NOT CONTROLMODE(OPERAND1) THEN ERROR(ERRBADMODE);
    IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
    CODEGEN;
    LISTINST(1);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
    END;

  18,27: { ADDI, SUBI, CMPI, ANDI, ORI, EORI }
	 IMMEDINSTR;


  20: { LINK }
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF OPERAND1.MODE<>1 THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF NOT((OPERAND2.MODE=7) AND (OPERAND2.REG=4)) THEN BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
       IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
       ESCAPE(OPSOK);
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND2.VALUE.OFFSET:=ZERO32;
	 OPERAND2.VALUE.BASE:=ABSOLUT;
	 OPERAND2.VALUE.EXPREFS:=NIL;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT +2 + SIZE;
     END;

  21: {MOVE, MOVEA }
     MOVEINSTR;


  22: {MOVEM}
      MOVEMINSTR;

  23: {MOVEP}
     BEGIN
     TRY
       PARSEOPERAND(OPERAND1);
       IF LINE[CURCOL]<>',' THEN BEGIN
	 ERROR(ERRCOMMAEXP);
	 ESCAPE(BADOPS);
       END;
       CURCOL:=CURCOL+1;
       PARSEOPERAND(OPERAND2);
       IF ((OPERAND1.MODE=0) AND (OPERAND2.MODE=5)) OR
	  ((OPERAND1.MODE=5) AND (OPERAND2.MODE=0)) THEN BEGIN
	   IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	    ESCAPE(OPSOK)
       END
       ELSE BEGIN
	 ERROR(ERRBADMODE);
	 ESCAPE(BADOPS);
       END;
     RECOVER
       IF ESCAPECODE=BADOPS THEN BEGIN
	 OPERAND1.MODE:=0;
	 OPERAND1.REG:=0;
	 OPERAND2.MODE:=5;
	 OPERAND2.VALUE.OFFSET:=ZERO32;
	 OPERAND2.VALUE.EXPREFS:=NIL;
	 OPERAND2.VALUE.BASE:=ABSOLUT;
       END
       ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
       CODEGEN;
       LISTINST(1);
       LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
     END;

  24: { MOVEQ }
     MOVEQINSTR;

  25: { SCC }
     BEGIN
     PARSEOPERAND(OPERAND1);
     IF NOT DATALTERABLE(OPERAND1) THEN ERROR(ERRBADMODE);
     IF LINE[CURCOL]<>' ' THEN ERROR(ERRBADSYNTAX);
     CODEGEN;
     LISTINST(1);
     LOCCTR.LONGINT := LOCCTR.LONGINT + 2+OPERAND1.SIZE;
     END;


  26: { NO OPERAND INSTRUCTIONS }
      BEGIN
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  28: {SWAP }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF OPERAND1.MODE<>0 THEN BEGIN
	OPERAND1.MODE:=0;
	OPERAND1.REG:=0;
	ERROR(ERRBADMODE);
      END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  29: { TRAP }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN BEGIN
	ERROR(ERRBADMODE);
	OPERAND1.VALUE.OFFSET:=ZERO32;
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.EXPREFS:=NIL;
      END;
      IF NOT((OPERAND1.VALUE.OFFSET.HIHALF=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF>=0) AND
	     (OPERAND1.VALUE.OFFSET.LOHALF<=15)) THEN
	       ERROR(ERRFIELDOFLO);
      IF OPERAND1.VALUE.EXPREFS<>NIL THEN BEGIN
	 OPERAND1.VALUE.EXPREFS:=NIL;
	 OPERAND1.VALUE.OFFSET:=ZERO32;
	 ERROR(ERREXTREFS);
      END;
      IF OPERAND1.VALUE.BASE<>ABSOLUT THEN
	BEGIN
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERRBADMODE);
	END;
      SIZE:=0;
      IF LINE[CURCOL]=',' THEN
	BEGIN
	SIZE:=2;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>7) OR (OPERAND2.REG<>4) THEN BEGIN
	  ERROR(ERRBADMODE);
	  OPERAND2.VALUE.OFFSET:=ZERO32;
	  OPERAND2.VALUE.BASE:=ABSOLUT;
	  OPERAND2.VALUE.EXPREFS:=NIL;
	IF OPERAND2.VALUE.BASE<>ABSOLUT THEN
	  BEGIN
	  OPERAND2.VALUE.BASE:=ABSOLUT;
	  OPERAND2.VALUE.OFFSET:=ZERO32;
	  ERROR(ERRBADMODE);
	  END;
      END;
	END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      IF SIZE=2
	THEN LOCCTR.LONGINT := LOCCTR.LONGINT + 4
	ELSE LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  30: { UNLK }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF OPERAND1.MODE<>1 THEN BEGIN
	OPERAND1.MODE:=1;
	OPERAND1.REG:=0;
	ERROR(ERRBADMODE);
      END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  31: { CMPM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND1.MODE<>3) OR (OPERAND2.MODE<>3) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=3;
	  OPERAND2.MODE:=3;
	  OPERAND1.REG:=0;
	  OPERAND2.REG:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  32: { MOVEC }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT((OPERAND1.MODE<=1) OR ((OPERAND1.MODE=7) AND
	       (OPERAND1.REG>=7))) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF ((OPERAND1.MODE<=1) AND NOT((OPERAND2.MODE=7) AND
	    (OPERAND2.REG>=7)))  OR  ((OPERAND1.MODE=7) AND
	    (OPERAND2.MODE>1)) THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG:=0;
	  OPERAND2.MODE:=7;
	  OPERAND2.REG:=7;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT+4;
      END;

  33: { MOVES }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN BEGIN
	  ERROR(ERRCOMMAEXP);
	  ESCAPE(BADOPS);
	END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT(((OPERAND1.MODE<=1) OR (OPERAND2.MODE<=1)) AND
	       (MEMALT(OPERAND1) OR MEMALT(OPERAND2)))  THEN BEGIN
	  ERROR(ERRBADMODE);
	  ESCAPE(BADOPS);
	END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN BEGIN
	  OPERAND1.MODE:=0; OPERAND1.REG:=0;
	  OPERAND2.MODE:=2; OPERAND2.REG:=0;
	  OPERAND1.SIZE:=0; OPERAND2.SIZE:=0;
	END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT + 4 + OPERAND1.SIZE +
	  OPERAND2.SIZE;
      END;

  34: { RTM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT(OPERAND1.MODE<=1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT:=LOCCTR.LONGINT+2;
      END;

  35: { BKPT }
      BEGIN
      PARSEOPERAND(OPERAND1);
      IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	BEGIN
	ERROR(ERRBADMODE);
	OPERAND1.VALUE.OFFSET:=ZERO32;
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.EXPREFS:=NIL;
	END;
      IF NOT((OPERAND1.VALUE.OFFSET.LONGINT>=0) AND
	     (OPERAND1.VALUE.OFFSET.LONGINT<=7)) THEN
	       ERROR(ERRFIELDOFLO);
      IF OPERAND1.VALUE.EXPREFS<>NIL THEN
	BEGIN
	OPERAND1.VALUE.EXPREFS:=NIL;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERREXTREFS);
	END;
      IF OPERAND1.VALUE.BASE<>ABSOLUT THEN
	BEGIN
	OPERAND1.VALUE.BASE:=ABSOLUT;
	OPERAND1.VALUE.OFFSET:=ZERO32;
	ERROR(ERRBADMODE);
	END;
      IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

  36: { TRAPcc }
      BEGIN
      TRY
	IF SIZESUFFIX=' ' THEN
	  BEGIN
	  SIZE:=0;
	  END
	ELSE
	  BEGIN
	  PARSEOPERAND(OPERAND1);
	  IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	    BEGIN
	    ERROR(ERRBADMODE);
	    ESCAPE(BADOPS);
	    END;
	  IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	  END;
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.VALUE.OFFSET:=ZERO32;
	  OPERAND1.VALUE.BASE:=ABSOLUT;
	  OPERAND1.VALUE.EXPREFS:=NIL;
	  OPERAND1.MODE:=7;
	  OPERAND1.REG :=4;
	  END;
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 2 + SIZE;
      END;

  37: { CALLM }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>7) OR (OPERAND1.REG<>4) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF (0>OPERAND1.VALUE.OFFSET.LONGINT) OR
	   (OPERAND1.VALUE.OFFSET.LONGINT>=256) THEN
	  BEGIN ERROR(ERRFIELDOFLO); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF NOT CONTROLMODE(OPERAND2) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=7;
	  OPERAND1.REG :=4;
	  OPERAND1.VALUE.OFFSET:=ZERO32;
	  OPERAND1.VALUE.EXPREFS:=NIL;
	  OPERAND1.VALUE.BASE:=ABSOLUT;
	  OPERAND1.SIZE:=1;
	  OPERAND2.MODE:=2;
	  OPERAND2.REG :=0;
	  OPERAND2.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND2.SIZE;
      END;

  38: { CAS }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF NOT MEMALT(OPERAND3) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=2;
	  OPERAND3.REG :=0;
	  OPERAND3.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND3.SIZE;
      END;

  39: { CAS2 }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF (OPERAND3.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND4);
	IF (OPERAND4.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND5);
	IF NOT (OPERAND5.MODE=2) AND            (* "(An)" *)
	   NOT ((OPERAND5.MODE=6) AND           (* "(Dn)" *)
		(OPERAND5.INDEXMODE=DATA) AND   (* also allows "(Dn.W*1)" *)
		(OPERAND5.INDEXSIZE=WRD ) AND
		(OPERAND5.INDEXSCALE=0  ) AND
		(OPERAND5.FULL_FORMAT)    AND
		(OPERAND5.BASE_SUPPRESS)  AND
		(NOT OPERAND5.INDEX_SUPPRESS) AND
		(OPERAND5.OD_SIZE=S_RES)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF OPERAND5.MODE=6 THEN
	  OPERAND5.REG:=OPERAND5.INDEX;
	IF LINE[CURCOL]<>':' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND6);
	IF NOT (OPERAND6.MODE=2) AND            (* "(An)" *)
	   NOT ((OPERAND6.MODE=6) AND           (* "(Dn)" *)
		(OPERAND6.INDEXMODE=DATA) AND   (* also allows "(Dn.W*1)" *)
		(OPERAND6.INDEXSIZE=WRD ) AND
		(OPERAND6.INDEXSCALE=0  ) AND
		(OPERAND6.FULL_FORMAT)    AND
		(OPERAND6.BASE_SUPPRESS)  AND
		(NOT OPERAND6.INDEX_SUPPRESS) AND
		(OPERAND6.OD_SIZE=S_RES)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF OPERAND6.MODE=6 THEN
	  OPERAND6.REG:=OPERAND6.INDEX;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  OPERAND4.MODE:=0;
	  OPERAND4.REG :=0;
	  OPERAND5.MODE:=2;
	  OPERAND5.REG :=0;
	  OPERAND6.MODE:=2;
	  OPERAND6.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 6;
      END;

  40: { CHK2, CMP2 }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT CONTROLMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE>1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=2;
	  OPERAND2.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  41: { PACK, UNPK }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND1.MODE<>OPERAND2.MODE) OR
	  ((OPERAND1.MODE<>0) AND (OPERAND1.MODE<>4)) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND3);
	IF (OPERAND3.MODE<>7) OR (OPERAND3.REG<>4) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=7;
	  OPERAND3.REG :=4;
	  OPERAND3.VALUE.OFFSET:=ZERO32;
	  OPERAND3.VALUE.EXPREFS:=NIL;
	  OPERAND3.VALUE.BASE:=ABSOLUT;
	  OPERAND3.SIZE:=2;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4;
      END;

  42: { BFCHG, BFCLR, BFSET, BFTST }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT ((OPERAND1.MODE=0) OR
	  ((CURROP.NAME<>'BFTST    ') AND CONTROLALTERABLE(OPERAND1)) OR
	  ((CURROP.NAME ='BFTST    ') AND      CONTROLMODE(OPERAND1))) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	PARSE_BITFIELD(BITFIELD);
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  43: { BFEXTS, BFEXTU, BFFFO }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) AND NOT CONTROLMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	PARSE_BITFIELD(BITFIELD);
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF (OPERAND2.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

  44: { BFINS }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF (OPERAND1.MODE<>0) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	PARSE_BITFIELD(BITFIELD);
	IF (OPERAND2.MODE<>0) AND NOT CONTROLALTERABLE(OPERAND2) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND2.SIZE:=0;
	  END
	ELSE IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
      CODEGEN;
      LISTINST(1);
      LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND2.SIZE;
      END;

  45: { DIV?.L, DIV?L.L, MUL?.L }
      BEGIN
      TRY
	PARSEOPERAND(OPERAND1);
	IF NOT DATAMODE(OPERAND1) THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]<>',' THEN
	  BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	CURCOL:=CURCOL+1;
	PARSEOPERAND(OPERAND2);
	IF OPERAND2.MODE<>0 THEN
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	IF LINE[CURCOL]=':' THEN
	  BEGIN
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND3);
	  IF OPERAND3.MODE<>0 THEN
	    BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	  IF CURROP.NAME[5]='L' THEN (* must be DIV?L.L *)
	    OPERAND2.MODE:=1  (***** special flag for 32bit mode *****)
	  END
	ELSE
	  BEGIN
	  IF CURROP.NAME[5]='L' THEN (* must be DIV?L.L *)
	    BEGIN ERROR(ERRSYMBEXP);{*} ESCAPE(BADOPS); END;
	  OPERAND3:=OPERAND2;
	  OPERAND2.MODE:=1; (***** special flag for 32bit mode *****)
	  END;
	IF LINE[CURCOL]<>' ' THEN ERROR(ERREOLEXP);
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + OPERAND1.SIZE;
      END;

    46: { MOVE16 - ADDED 6/30/89 JWH }
     BEGIN
      bump_value := 0;
      TRY
	PARSEOPERAND(OPERAND1);
	case operand1.MODE of
	 2: { (An) }
	   begin
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF OPERAND2.MODE <> 7 then { Oh Oh }
	      begin error(ERRBADMODE); escape(BADOPS); end
	    else
	     begin
	      bump_value := 2;
	      IF ((OPERAND2.VALUE.EXPREFS <> NIL) and
		  (OPERAND2.SIZE <> 4)) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     end;
	   end; { operand1.MODE = 2 }
	 3: { (An)+ }
	   begin
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF (OPERAND2.MODE <> 7) then { better be 3 }
	     BEGIN
	      IF (OPERAND2.MODE <> 3) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     END
	    ELSE { op2.mode = 7 }
	     begin
	      bump_value := 2;
	      IF ((OPERAND2.VALUE.EXPREFS <> NIL) and
		  (OPERAND2.SIZE <> 4)) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	     end;
	   end; { operand1.MODE = 3 }
	 7: { Expr - absolute mode }
	   begin
	    bump_value := 2;
	    IF ((OPERAND1.VALUE.EXPREFS <> NIL) and
		(OPERAND1.SIZE <> 4)) then { Oh Oh }
	      begin error(ERRBADMODE); escape(BADOPS); end;
	    IF LINE[CURCOL]<>',' THEN
	      BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	    CURCOL:=CURCOL+1;
	    PARSEOPERAND(OPERAND2);
	    IF (OPERAND2.MODE <> 2) then { better be 3 }
	      IF (OPERAND2.MODE <> 3) then { Oh Oh }
	       begin error(ERRBADMODE); escape(BADOPS); end;
	   end; { operand1.MODE = 7 (absolute ) }
	 otherwise
	   begin error(ERRBADMODE); escape(BADOPS); end;
	end; { CASE OPERAND1.MODE OF }
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE := bump_value; { used by gencode }
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 4 + bump_value;
      END;
  47,48,49,50,51,52: { CINVL,CINVP,CINVA,CPUSHL,CPUSHP,CPUSHA }
      BEGIN
      TRY
	OPERAND1.MODE := PARSE_CACHES;
	if OPERAND1.MODE = 0 then
	  BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	if ((currop.CLASS = 49) or (currop.CLASS = 52)) THEN
		{ CINVA,CPUSHA  have no 2nd operand }
	  begin
	   if line[CURCOL] <> ' ' then
	    begin error(erreolexp); escape(badops); end;
	  end;
	if ((currop.CLASS <> 49) and (currop.CLASS <> 52)) THEN
		{ CINVA,CPUSHA  have no 2nd operand }
	 begin
	  IF LINE[CURCOL]<>',' THEN
	    BEGIN ERROR(ERRCOMMAEXP); ESCAPE(BADOPS); END;
	  CURCOL:=CURCOL+1;
	  PARSEOPERAND(OPERAND2);
	  if OPERAND2.MODE <> 2 then
	    BEGIN ERROR(ERRBADMODE); ESCAPE(BADOPS); END;
	 end;
	ESCAPE(OPSOK);
      RECOVER
	IF ESCAPECODE=BADOPS THEN
	  BEGIN
	  OPERAND1.MODE:=0;
	  OPERAND1.REG :=0;
	  OPERAND1.SIZE:=0;
	  OPERAND2.MODE:=0;
	  OPERAND2.REG :=0;
	  OPERAND3.MODE:=0;
	  OPERAND3.REG :=0;
	  END
	ELSE
	  IF ESCAPECODE<>OPSOK THEN ESCAPE(ESCAPECODE);
	CODEGEN;
	LISTINST(1);
	LOCCTR.LONGINT := LOCCTR.LONGINT + 2;
      END;

END; { OF CASE }
END;   { OF PASS2STUFF }



BEGIN
GETLINE;
WHILE (LINE<>' END') AND
      (CURROP.NAME<>'END      ') DO BEGIN
  IF ODD(LOCCTR.LOHALF) AND NOT((
     ( CURROP.NAME='DC       ') OR
     (CURROP.NAME='DS       ')) AND (SIZE=1))
     and (currop.name<>'         ') THEN BEGIN
    if contiguous then PUNCHBYTE(0);
    LOCCTR.LONGINT := LOCCTR.LONGINT + 1;
  END;
  IF (LAB<>'') AND NOT((CURROP.CLASS=99)
	AND ((CURROP.CODE=5) OR (CURROP.CODE=13)
	      OR (CURROP.CODE=15))) THEN BEGIN
    LOOKUPSYMBOL(SP);
    IF NOT(SP^.EXT) AND ((SP^.SVALUE.LOHALF<>LOCCTR.LOHALF)
	 OR (SP^.SVALUE.HIHALF<>LOCCTR.HIHALF)) THEN ERROR(ERRPHASE);
  END;
  OPERAND1.VALUE.EXPREFS:=NIL;
  OPERAND2.VALUE.EXPREFS:=NIL;
  OPERAND3.VALUE.EXPREFS:=NIL;
  OPERAND4.VALUE.EXPREFS:=NIL;
  OPERAND5.VALUE.EXPREFS:=NIL;
  OPERAND6.VALUE.EXPREFS:=NIL;
  PASS2STUFF;
  IF OPERAND1.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND1.VALUE.EXPREFS);
  IF OPERAND2.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND2.VALUE.EXPREFS);
  IF OPERAND3.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND3.VALUE.EXPREFS);
  IF OPERAND4.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND4.VALUE.EXPREFS);
  IF OPERAND5.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND5.VALUE.EXPREFS);
  IF OPERAND6.VALUE.EXPREFS<>NIL THEN DISPOSE(OPERAND6.VALUE.EXPREFS);
  IF ERRINLINE THEN BEGIN
    ERRINLINE:=FALSE;
    LISTERROR(LINEERRCODE);
  END;
  GETLINE;
END;
LISTINST(4);   { LIST END LINE }
END;


@


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.4
log
@

          
             Adjusted processing for CINVA and CPUSHA to flag
       an error when something other than blank or eol follows
       the first argument.
@
text
@@


41.3
log
@

       Tightened up the MOVE16 processing.
@
text
@d1787 6
@


41.2
log
@

         Adjusted the processing for ADD and SUB to force
     ADD to ADDA and SUB to SUBA when the destination
     register is an 'A' register.

       JWH 12/26/89.
@
text
@d1769 1
a1769 1
	  OPERAND1.SIZE:=0;
@


41.1
log
@Automatic bump of revision number for PWS version 3.23d
@
text
@d33 6
d51 3
a53 3
      {ERROR(ERRBADMODE);}                { JWH 11/21/89 }
      {ESCAPE(BADOPS);}                   { JWH 11/21/89 }
      ESCAPE(OPSOK);                {jch  08/26/86}
@


40.4
log
@
pws2rcs automatic delta on Thu Dec 21 14:54:59 MST 1989
@
text
@@


40.3
log
@

        Modified routine ADDSANDSUBS to fix what appears to
     be an erroneuos modification made to this routine
     on 8/26/86.

         JWH 11/21/89.
@
text
@d45 3
a47 3
      ERROR(ERRBADMODE);                { JWH 11/21/89 }
      ESCAPE(BADOPS);                   { JWH 11/21/89 }
      { ESCAPE(OPSOK); }                {jch  08/26/86}
@


40.2
log
@

         Added code to handle the new 68040 instructions MOVE16,
    CINV, and CPUSH.

         JWH 11/21/89.
@
text
@d40 4
d45 3
a47 1
      ESCAPE(OPSOK);                    {jch  08/26/86}
@


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


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.1
log
@Automatic bump of revision number for PWS version 3.2G
@
text
@@


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.1
log
@Automatic bump of revision number for PWS version 3.2A
@
text
@@


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


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.2
log
@changes to be able to assemble PAWS C compiler output
@
text
@@


2.1
log
@Auto bump rev number to 2.1 for sys 3.2e.
@
text
@d1 4
d40 2
a41 2
      ERROR(ERRBADMODE);
      ESCAPE(BADOPS);
d216 1
a216 1
      ERROR(ERRBADMODE);  { MOVE TO AN WITHOUT MOVEA }
d338 1
d398 2
a399 1
  IF CHECKREGS THEN BEGIN
d405 6
a410 1
    FORMMASK;
d418 2
a419 1
      FOR I:=0 TO 15 DO TEMP.BITS[31-I]:=MASK.BITS[16+I];
d442 1
a442 1
    IF NOT CHECKREGS THEN BEGIN
d453 7
a459 1
    FORMMASK;
d478 1
a478 1
      OPERAND1.VALUE.OFFSET:=MASK;
d483 1
a483 1
      OPERAND2.VALUE.OFFSET:=MASK;
@


1.1
log
@Initial revision
@
text
@@
