


    /* EPC Imp to C Translation Release 4 Version Apr 95 */


#include "imptoc.h"

/* Copyright (c) 1988 Edinburgh Portable Compilers Ltd. All Rights Reserved.  */
/**/
/*     ECODES                                                                */
/*     ------                                                                */
/**/
/*     Author : Geoff Millard      Created on : 09 Feb 88                    */
/**/
/*     Modifications :                                                       */
/**/
/*     Date     Dev Vers   Description of Modification                       */
/*     ----     --- ----   ---------------------------                       */
/*     17-11-93  pds  36   Added SETOPTIONs for Pascal & EADDRITIEM          */
/*     04/11/92  AK   35.1 Added EIMERGE1, ERMERGE1, EMERGE2,                */
/*                         and DCXMERGE for Fortran90                        */
/*     06/08/91  AK   35   Renamed ecodes33.6                                */
/*     02/04/91  RT   33.6 Removed ECCOps LOGVAL,LOGSTK and LOGNEG           */
/*     05/12/90  RT   33.5 Added ECOps CJTRUE, CJFALSE, CDUPADD and CDUPSUB  */
/*     18/04/90  CMcP 33.4 Add Pascal-E operators STRTOCH,STRPLUS,STRMOVE,PUSHSTR*/
/*     09/03/90  GM   33.3 Add operator DCXUCHECK                            */
/*     22/02/90  TR   33.2 Renumber the bit Pasops since pascal-I/E conflict */
/*     28/01/90  AK   33.1 Merge Pascal changes (from 32.6)                  */
/*     07/01/90  GM   33   Common version                                    */
/*     25/01/90  TR   32.6 Add BITADDR for Pascal                            */
/*     23/01/90  TR   32.6 Add SAVEBITREF and RESTBITREF for Pascal          */
/*     22/01/90  TR   32.6 Add UPBITII, UPBITUU, UPBITIU, UPBITUI for Pascal */
/*                         and rename INDEXP as INDEXBITS                    */
/*     18/12/89  AK   32.5 Merge Pascal changes                              */
/*     01/12/89  TR   32   Reinstate BNOT as generic EOP                     */
/*     28/11/89  TR   32   Add PasOps RCHKRNG and RCHKXX                     */
/*     30/11/89  GM   32.4 Merge Pascal changes                              */
/*     30/10/89  TR   32   Add PasOp CHKUOVF to complement CHKIOVF           */
/*     27/10/89 AJH   32   Add PasOps BAND BOR BNOT                          */
/*     22/11/89  GM   32.2 Add direct complex ops                            */
/*     29/08/89 AJH   32   Reduced set of Pascal/Modula ecodes               */
/*     09/08/89  TR   32   Rename PIMOD to INMOD and add UNMOD & IMDIV       */
/*     24/05/89  TR   32   Add SETSD, SETINCL, SETEXCL & remove SETEMPTY     */
/*     28/02/89  GB   32   Add operator PSEUDONOP                            */
/*     09/12/88  GB   31   Add operator GATHER                               */
/*     04/12/88  GB   30   Add operators FORCE, ENDFORCE                     */
/*     11/10/88  GB   30   Add operator VCSEDEF                              */
/*     07/06/88  GB   29   Add operator VVSUB                                */
/*     04/09/88  GM   28   Basis version for tracking changes                */
/**/
#define HALT 0	/*00*/
/**/
/*--------------------------------------- generic int operations -------     */
/**/
#define IADD 1	/*01*/	/* (Etos-1) + (Etos) => (Etos)   */
#define ISUB 2	/*02*/	/* (Etos-1) - (Etos) => (Etos)   */
#define IMULT 3	/*03*/	/* (Etos-1) * (Etos) => (Etos)   */
#define IDIV 4	/*04*/	/* (Etos-1) / (Etos) => (Etos)   */
#define INEG 5	/*05*/	/*          - (Etos) => (Etos)   */
#define IABS 6	/*06*/	/*     abs( (Etos) ) => (Etos)   */
#define IREM 7	/*07*/	/* remainder from                */
		 	/*  (Etos-1) / (Etos)=> (Etos)   */
/**/
#define IAND 8	/*08*/	/* (Etos-1) & (Etos) => (Etos)   */
#define IOR 9	/*09*/	/* (Etos-1) ! (Etos) => (Etos)   */
#define INOT 10	/*0A*/	/*          ~ (Etos) => (Etos)   */
#define IXOR 11	/*0B*/	/* (Etos-1) !! (Etos) => (Etos)  */
#define ISHLL 12/*0C*/	/* (Etos-1) << (Etos) => (Etos)  */
#define ISHRL 13/*0D*/	/* (Etos-1) >> (Etos) => (Etos)  */
#define ISHLA 14/*0E*/	/* arithmetic left shift         */
#define ISHRA 15/*0F*/	/* arithmetic right shift        */
/**/
#define IGT 16	/*10*/	/* if                            */
#define ILT 17	/*11*/	/*    (Etos-1) <relop> (Etos)    */
#define IEQ 18	/*12*/	/* then                          */
#define INE 19	/*13*/	/*    true  (1) => (Etos)        */
#define IGE 20	/*14*/	/* else                          */
#define ILE 21	/*15*/	/*    false (0) => (Etos)        */
#define BNOT 22	/*16*/	/*  (Etos) = BNOT (Etos) 0<->1   */
/**/
#define JIGT 24	/*18*/	/* if                            */
#define JILT 25	/*19*/	/*    (Etos-1) <relop> (Etos)    */
#define JIEQ 26	/*1A*/	/* then                          */
#define JINE 27	/*1B*/	/*    -> <label>                 */
#define JIGE 28	/*1C*/	/* else                          */
#define JILE 29	/*1D*/	/*    continue                   */
/**/
#define JINTGZ 30	/*1E*/	/* if (Etos) > 0 %then -> <lab>  */
#define JINTLZ 31	/*1F*/	/* if (Etos) < 0 %then -> <lab>  */
#define JINTZ 32	/*20*/	/* if (Etos) = 0 %then -> <lab>  */
#define JINTNZ 33	/*21*/	/* if (Etos) # 0 %then -> <lab>  */
#define JINTGEZ 34	/*22*/	/* if (Etos) >=0 %then -> <lab>  */
#define JINTLEZ 35	/*23*/	/* if (Etos) <=0 %then -> <lab>  */
/**/
#define ITWB 36	/*24*/	/* if (Etos) < 0 then -> <lab1>  */
			/*           = 0 then -> <lab2>  */
			/*           > 0 then -> <lab3>  */
/**/
/*--------------------------------------- miscellaneous operations------     */
/**/
#define JUMP 38		/*26*/	/* -> <label>                    */
#define SFA 41		/*29*/	/* SF => (Etos)                  */
#define RETURN 42	/*2A*/	/* procedure exit                */
#define ASF 43		/*2B*/	/* SF = SF + (Etos)              */
/**/
#define IPUSH 44	/*2C*/	/* (Etos) => (Mstack)            */
#define IPOP 45		/*2D*/	/* (Mstack) => (Etos)            */
#define EXCH 46		/*2E*/	/* (Etos-1) <=> (Etos)           */
#define DUPL 47		/*2F*/	/* replicate (Etos)              */
#define DISCARD 48	/*30*/	/* discard (Etos)                */
/**/
#define INDEX1 51	/*33*/	/* (@ Etos-1) + (Etos)           */
				/*               => (@ Etos)     */
#define INDEX2 52	/*34*/	/* (@ Etos-1) + (Etos)*2         */
				/*               => (@ Etos)     */
#define INDEX4 53	/*35*/	/* (@ Etos-1) + (Etos)*4         */
				/*               => (@ Etos)     */
#define INDEX8 54	/*36*/	/* (@ Etos-1) + (Etos)*8         */
				/*               => (@ Etos)     */
#define INDEX 55	/*37*/	/* (@ Etos-2)                    */
				/*     + (Etos-1)*(Etos)         */
				/*               => (@ Etos)     */
/**/
#define MVB 56	/*38*/	/* move (Etos) bytes             */
		 	/*  ((@ Etos-2)) => ((@ Etos-1)) */
/**/
#define CHK 57	/*39*/	/* check that                    */
		 	/* (Etos-1)<=(Etos-2)<=(Etos)    */
		 	/* (Etos-2) => (Etos)            */
/**/
#define TMASK 58	/*3A*/	/* (Etos-1) & (Etos)             */
		 	/* - to be followed by JI[N]Z    */
#define MVW 59	/*3B*/	/* move (Etos) words - aligned   */
		 	/*  ((@ Etos-2)) => ((@ Etos-1)) */
#define EZERO 60	/*3C*/	/* (Etos) bytes at ((@ Etos-1))=0*/
/**/
#define CPBGT 62	/*3E*/	/* if (Etos) bytes               */
#define CPBLT 63	/*3F*/	/*  ((Etos-2)) <relop> ((Etos-1))*/
#define CPBEQ 64	/*40*/	/* then                          */
#define CPBNE 65	/*41*/	/*    true  (1) => (Etos)        */
#define CPBGE 66	/*42*/	/* else                          */
#define CPBLE 67	/*43*/	/*    false (0) => (Etos)        */
#define EMAKED 68	/*44*/	/* (Etos) = (Etos)<<32 ! (Etos-1)*/
		 	/*  64bit    32bit        32bit  */
#define ESPLITD 69	/*45*/	/* (Etos) => (Etos)   ,  (Etos-1)*/
/**/
/*-------------------------------------- generic unsigned operations ---     */
/**/
#define UMULT 77/*4D*/	/* unsigned mult                 */
#define UREM 78	/*4E*/	/* remainder - unsigned op       */
#define UDIV 79	/*4F*/	/* (Etos-1) / (Etos) => (Etos)   */
#define UADD 80	/*50*/	/* (Etos-1) + (Etos) => (Etos)   */
#define USUB 81	/*51*/	/* (Etos-1) - (Etos) => (Etos)   */
 
#define UGT 82	/*52*/	/* if                            */
#define ULT 83	/*53*/	/*    (Etos-1) <relop> (Etos)    */
#define UEQ 84	/*54*/	/* then                          */
#define UNE 85	/*55*/	/*    1 => (Etos)                */
#define UGE 86	/*56*/	/* else                          */
#define ULE 87	/*57*/	/*    0 => (Etos)                */
 
#define JUGT 88	/*58*/	/* if                            */
#define JULT 89	/*59*/	/*    (Etos-1) <relop> (Etos)    */
#define JUEQ 90	/*5A*/	/* then                          */
#define JUNE 91	/*5B*/	/*    -> <label>                 */
#define JUGE 92	/*5C*/	/* else                          */
#define JULE 93	/*5D*/	/*    continue                   */
 
#define JUGTZ 94	/*5E*/	/* if (Etos) > 0 %then -> <lab>  */
#define JULTZ 95	/*5F*/	/* if (Etos) < 0 %then -> <lab>  */
#define JUEQZ 96	/*60*/	/* if (Etos) = 0 %then -> <lab>  */
#define JUNEZ 97	/*61*/	/* if (Etos) # 0 %then -> <lab>  */
#define JUGEZ 98	/*62*/	/* if (Etos) >=0 %then -> <lab>  */
#define JULEZ 99	/*63*/	/* if (Etos) <=0 %then -> <lab>  */
 
#define UCVTII 100	/*64*/	/* (int Etos-1) => int size(Etos)*/
/**/
/*---------------------------------- generic int operations to store----     */
/**/
#define IADDST 101	/*65*/	/* ((Etos-1)) = (Etos-1)+(Etos)   */
#define ISUBST 102	/*66*/	/* ((Etos-1)) = (Etos-1)-(Etos)   */
#define IMULTST 103	/*67*/	/* ((Etos-1)) = (Etos-1)*(Etos)   */
#define IDIVST 104	/*68*/	/* ((Etos-1)) = (Etos-1)/(Etos)   */
#define INEGST 105	/*69*/	/* ((Etos))   = - (Etos)          */
/**/
#define UREMST 106	/*6A*/	/* unsigned remainder to store    */
#define UDIVST 107	/*6B*/	/* unsigned div to store          */
#define IANDST 108	/*6C*/	/* ((Etos-1)) = (Etos-1)&(Etos)   */
#define IORST 109	/*6D*/	/* ((Etos-1)) = (Etos-1)!(Etos)   */
#define INOTST 110	/*6E*/	/* ((Etos))   = ~ (Etos)          */
#define IXORST 111	/*6F*/	/* ((Etos-1)) = (Etos-1)!!(Etos)  */
#define IREMST 112	/*76*/	/* signed remainder to store      */
/**/
/*-------------------------------------- generic real operations -------     */
/**/
#define RADD 113	/*71*/	/* (Etos-1) + (Etos) => (Etos)    */
#define RSUB 114	/*72*/	/* (Etos-1) - (Etos) => (Etos)    */
#define RMULT 115	/*73*/	/* (Etos-1) * (Etos) => (Etos)    */
#define RDIV 116	/*74*/	/* (Etos-1) / (Etos) => (Etos)    */
#define RNEG 117	/*75*/	/*        - (Etos) => (Etos)      */
#define RABS 118	/*76*/	/*   abs( (Etos) ) => (Etos)      */
/**/
#define TNCRU 130	/*82*/	/* (real Etos-1) =>uns size(Etos) */
#define CVTSBI 131	/*83*/	/* (sbyte Etos-1)=>int size(Etos) */
#define CVTUI 132	/*84*/	/* (uns Etos-1) => int size(Etos) */
#define CVTUR 133	/*85*/	/* (uns Etos-1) => real size(Etos)*/
#define CVTIU 134	/*86*/	/* (int Etos-1) => uns size(Etos) */
#define CVTRU 135	/*87*/	/* (real Etos-1) => uns size(Etos)*/
#define CVTII 136	/*88*/	/* (int Etos-1) => int size(Etos) */
#define CVTIR 137	/*89*/	/* (int Etos-1) => real size(Etos)*/
#define CVTRR 138	/*8A*/	/* (real Etos-1)=> real size(Etos)*/
#define TNCRI 139	/*8B*/	/* (real Etos-1)=> int size(Etos) trunc toward 0*/
#define RNDRI 140	/*8C*/	/* (real Etos-1)=> int size(Etos) to nearest int*/
#define EFLOOR 141	/*8D*/	/* (real Etos-1)=> int size(Etos)  towards -inf */
#define TNCRR 142	/*8E*/	/* (real Etos-1)=> real size(Etos) trunc toward 0*/
#define RNDRR 143	/*8F*/	/* (real Etos-1)=> real size(Etos) to nearest int*/
/**/
#define RGT 144	/*90*/	/* if                            */
#define RLT 145	/*91*/	/*    (Etos-1) <relop> (Etos)    */
#define REQ 146	/*92*/	/* then                          */
#define RNE 147	/*93*/	/*    1 => (Etos)                */
#define RGE 148	/*94*/	/* else                          */
#define RLE 149	/*95*/	/*    0 => (Etos)                */
/**/
#define JRGT 150	/*96*/	/* if                            */
#define JRLT 151	/*97*/	/*    (Etos-1) <relop> (Etos)    */
#define JREQ 152	/*98*/	/* then                          */
#define JRNE 153	/*99*/	/*    -> <label>                 */
#define JRGE 154	/*9A*/	/* else                          */
#define JRLE 155	/*9B*/	/*    continue                   */
/**/
#define JRGZ 156	/*9C*/	/* if (Etos) > 0 %then -> <lab>  */
#define JRLZ 157	/*9D*/	/* if (Etos) < 0 %then -> <lab>  */
#define JRZ 158		/*9E*/	/* if (Etos) = 0 %then -> <lab>  */
#define JRNZ 159	/*9F*/	/* if (Etos) # 0 %then -> <lab>  */
#define JRGEZ 160	/*A0*/	/* if (Etos) >=0 %then -> <lab>  */
#define JRLEZ 161	/*A1*/	/* if (Etos) <=0 %then -> <lab>  */
/**/
#define RTWB 162	/*A2*/	/* if (Etos) < 0 then -> <lab1>  */
		 	/*           = 0 then -> <lab2>  */
		 	/*           > 0 then -> <lab3>  */
#define JTRUE 163	/*A3*/	/* if (Etos) true  then -> <lab  */
#define JFALSE 164	/*A4*/	/* if (Etos) false then -> <lab> */
/**/
/*----------------------------------------------------------------------     */
/**/
#define UCHECK 177	/*B1*/	/* if (Etos) unassigned diagnose  */
#define ESTORE 184	/*B8*/	/* ((Etos)) = (Etos-1)            */
#define EDUPSTORE 185	/*B9*/	/* ((Etos)) = (Etos-1)            */
		 	/* retain (Etos-1) as new (Etos)  */
#define PUSHVAL 186	/*BA*/	/* push (Etos) as value param     */
#define PUSHADDR 187	/*BB*/	/* push (Etos) as ref param       */
#define EVAL 188	/*BC*/	/* force load of (Etos)           */
#define EVALADDR 189	/*BD*/	/* force load of @ at (Etos)      */
#define EADDRESS 190	/*BE*/	/* address(Etos) is required      */
#define EINTRES 191	/*BF*/	/* (Etos) is integer fn result    */
#define EREALRES 192	/*C0*/	/* (Etos) is real fn result       */
#define ESIZE 193	/*C1*/	/* size of (Etos-1) is (Etos)     */
 
#define EPOWER 194	/*C2*/	/* (Etos-3) @ result if cx        */
		 	/* (Etos-2) base (@ base if cx)   */
		 	/* (Etos-1) power(@ power if cx)  */
		 	/* (Etos)   procindex             */
 
#define EPOWERI 195	/*C3*/	/* (Etos-2) base                  */
		 	/* (Etos-1) power (int)           */
		 	/* (Etos)   procindex (0-3)       */
 
		 	/* procindex =  0  powii          */
		 	/*              1  powri          */
		 	/*              2  powdi          */
		 	/*              3  powqi          */
		 	/*              4  powci          */
		 	/*              5  powzi          */
		 	/*              6  powzzi         */
		 	/*              9  powrr          */
		 	/*             10  powdd          */
		 	/*             11  powqq          */
		 	/*             12  powcc          */
		 	/*             13  powzz          */
		 	/*             14  powzzz         */
 
#define ARGPROC 196	/*C4*/	/* call formal procedure in (Etos)*/
#define PUSHBYTES 197	/*C5*/	/* push (Etos) bytes from         */
			 	/* (@etos-1) as value parameter   */
#define EAUXSF 198	/*C6*/	/* AUXSF => (ETOS)                */
#define EAUXADD 199	/*C7*/	/* AUXSF = AUXSF + (ETOS)         */
#define EAUXRES 200	/*C8*/	/* AUXSF = (ETOS)                 */
#define EOLDLNB 201	/*C9*/	/* stack LNB needed for diags     */
#define EFILL 202	/*CA*/	/*fill (ETOS-1) bytes at (ETOS-2) with (ETOS) */
#define ECDUP 203	/*CB*/	/*temp! next ..ST to restack val  */
#define EADDRITEM 204	/*CC*/	/* address of single item (Etos) required */
#define EMCHIP 205	/*CD*/	/* apply chip fn (ETOS) to arg (ETOS-1) */
/**/
#define WHEREMASK 244	/*F4*/	/* (Etos) is where mask expression*/
#define WHERELSE 245	/*F5*/	/* ELSEWHERE                      */
#define VELOG 246	/*F6*/	/* eval comparison to logical     */
#define WHEREST 247	/*F7*/	/* WHERE start  (ETOS) = mask     */
#define WHEREND 248	/*F8*/	/* WHERE end                      */
#define VSEQR 249	/*F9*/	/* SEQ real etos=start,etos-1=inc; sv inc!*/
#define VSEQI 250	/*FA*/	/* SEQ int etos=start,etos-1=inc; sv inc!*/
#define VMASK 251	/*FB*/	/* (ETOS) is logical mask */
#define VIMAGPT 252	/*FC*/	/* (ETOS,complex) => (ETOS,imag part)*/
#define VREALPT 253	/*FD*/	/* (ETOS,complex) => (ETOS,real part)*/
#define VSTART 254	/*FE*/	/* start of vector loop           */
			 	/* (Etos) = no. of elements       */
#define VEND 255	/*FF*/	/* end of vector loop             */
/**/
/*************************************************************************/
/**                                                                     **/
/**                       FORTRAN specific codes                        **/
/**                                                                     **/
/*************************************************************************/
/**/
 	/*Complex operations using Indirect Operands and Nominated Result Location*/
/**/
#define CXADD 257	/* ((Etos-3)) = ((Etos-2))        */
#define CXSUB 258	/*                      op        */
#define CXMULT 259	/*                      ((Etos-1))*/
#define CXDIV 260	/* (Etos) = variant<<8 ! sizecode */
 
#define CXNEG 261	/* ((Etos-2)) = - ((Etos-1))      */
		 	/* (Etos) = sizecode              */
 
#define CXASGN 262	/* ((Etos-2)) = ((Etos-1))        */
		 	/* (Etos) = variant<<8            */
		 	/*            ! sizecode(RHS)<<2  */
		 	/*              ! sizecode(LHS)   */
 
#define CXEQ 263	/* (Etos) =  ((Etos-2))           */
#define CXNE 264	/*                  op ((Etos-1)) */
		 	/* (Etos) = variant<<8 ! sizecode */
 
#define ECMPLX1 286	/* ((Etos-2))=((Etos-1),0)        */
#define ECMPLX2 287	/* ((Etos-3))=((Etos-2),(Etos-1)) */
		 	/* (Etos) = sizecode              */
 
#define ECONJG 279	/* ((Etos-2) =  conjg((Etos-1))   */
		 	/* (Etos) = sizecode              */
 
 	/*Complex Operations using Direct Operations. Result on Stack*/
 
#define DCXADD 337	/* (Etos-2) op (Etos-1) => Etos   */
#define DCXSUB 338	/*                                */
#define DCXMULT 339	/* Initial (Etos) is              */
#define DCXDIV 340	/*          variant<<8 ! sizecode */
 
#define DCXNEG 341	/*  - (Etos-1) => Etos            */
		 	/* Initial (Etos) is sizecode     */
 
#define DCXASGN 342	/* (Etos-1) = (Etos-2)            */
		 	/* (Etos) is                      */
		 	/* variant<<8 ! sizecode(LHS)<<2  */
		 	/*            ! sizecode(RHS)     */
#define DCXCVT 343	/* Convert (Etos-1) => Etos       */
		 	/* (Etos) is                      */
		 	/* variant<<8 ! newsizecode<<2    */
		 	/*            ! sizecode(Etos-1)  */
 
#define DCXEQ 344	/* (Etos-2) op (Etos-1) => Etos   */
#define DCXNE 345	/* Initial (Etos) is              */
		 	/*          variant<<8 ! sizecode */
 
#define DECMPLX1 346	/* ((Etos-1),0) => Etos           */
#define DECMPLX2 347	/* ((Etos-2),(Etos-1)) => Etos    */
		 	/* Initial (Etos) is sizecode     */
 
#define DECONJG 349	/* conjg (Etos-1) => Etos         */
		 	/* Initial (Etos) is sizecode     */
 
#define DCXUCHECK 350	/* perform unassigned check       */
		 	/*      on (Etos-1)               */
		 	/* Initial (Etos) is sizecode     */
 
#define DCXMERGE 351	/* if                             */
		 	/*    (Etos-1)                    */
		 	/* then                           */
		 	/*    (Etos-3) => (Etos)          */
		 	/* else                           */
		 	/*    (Etos-2) => (Etos)          */
		 	/*                                */
		 	/* Initial (Etos) is sizecode     */
 
		 	/* variant  = 0    cx op cx       */
		 	/*            1    cx op real     */
		 	/*            2  real op cx       */
		 	/* sizecode = 0    c*8   (r*4)    */
		 	/*            1    c*16  (r*8)    */
		 	/*            2    c*32  (r*16)   */
 
#define EM1EXP 267	/* (Etos) = (-1) ** (Etos) - int  */
 
#define EISIGN 268	/* (Etos) = sign(Etos)            */
#define ESIGN 269	/*                  * abs(Etos-1) */
 
#define EIMOD 270	/* (Etos) = int(Etos-1)/(Etos)    */
#define ERMOD 271	/*                       * (Etos) */
 
#define EIDIM 272	/* (Etos) = if (Etos-1) > (Etos)  */
#define ERDIM 273	/*          then (Etos-1)-(Etos)  */
		 	/*          else 0		*/
 
#define EIMIN 274	/* (Etos) = min( (Etos-1),        */
#define ERMIN 275	/*                (Etos) )        */
 
#define EIMAX 276	/* (Etos) = max( (Etos-1),        */
#define ERMAX 277	/*                (Etos) )        */
 
#define EDMULT 278	/* (Etos) = dble((Etos-1)*(Etos)) */
 
#define ECHAR 280	/*  ((Etos-1)) = char(Etos)       */
#define EICHAR 281	/*      (Etos) = ichar((Etos-1))  */
 
#define EINDEXCHAR 282	/*      (Etos) = index( C1,C2 )   */
		 	/*  ((Etos-3)) = Charad(C1)       */
		 	/*   (Etos-2)  = Charlen(C1)      */
		 	/*  ((Etos-1)) = Charad(C2)       */
		 	/*    (Etos)   = Charlen(C2)      */
 
#define ECONCAT 283	/*          C1 = concat list      */
		 	/*  ((Etos-3)) = @ concat table   */
		 	/*   (Etos-2)  = no. items        */
		 	/*  ((Etos-1)) = Charad(C1)       */
		 	/*    (Etos)   = Charlen(C1)      */
 
#define EASGNCHAR 284	/*          C1 = C2               */
		 	/*  ((Etos-3)) = Charad(C1)       */
		 	/*   (Etos-2)  = Charlen(C1)      */
		 	/*  ((Etos-1)) = Charad(C2)       */
		 	/*    (Etos)   = Charlen(C2)      */
 
#define ECOMPCHAR 285	/*     (Etos) = compare( C1,C2 )  */
		 	/*  ((Etos-4)) = Charad(C1)       */
		 	/*   (Etos-3)  = Charlen(C1)      */
		 	/*  ((Etos-2)) = Charad(C2)       */
		 	/*   (Etos-1)  = Charlen(C2)      */
		 	/*    (Etos)   = relop            */
		 	/*  relop  =  0 >   1 <   2 =     */
		 	/*            3 #   4 >=  5 <=    */
 
#define EISHFT 288	/* (Etos) = (Etos-1) << (Etos)    */
#define EIBITS 289	/* (Etos) = (Etos) bits from      */
		 	/*       bit (Etos-1) in (Etos-2) */
#define EIBSET 290	/* (Etos) = (Etos-1)&(1<<(Etos))  */
#define EIBTEST 291	/* (Etos) = (Etos-1)!(1<<(Etos))  */
#define EIBCLR 292	/* (Etos) = (Etos-1)&\(1<<(Etos)) */
#define EISHFTC 293	/* (Etos) = (Etos-1) <<c (Etos)   */
 
#define PROCARG 294	/* (Etos) = Procref(Etos)         */
#define ARGPROCCALL 298	/*   (Etos)   = paramsize(bytes)  */
		 	/*   (Etos-1) = arg               */
 
#define CALLTPLATE 299	/* not used                       */
#define NOTEIORES 300	/* preserve io fn result(no stack change) */
#define STKIORES 301	/* restack io fn result           */
 
 
#define EFDVACC 305	/* dope vector special evaluation */
		 	/* (Etos-1) => (Etos)             */
		 	/* (Etos-2) + (Etos-1)*(Etos)     */
		 	/*                => (Etos-1)     */
 
#define EFNOTEVR 306	/* (Etos) is the variable return  */
		 	/* index                          */
 
#define EFSETVR 307	/* stack a descriptor for the     */
		 	/* variable return index          */
 
#define EINCR 308	/* equiv to IADDST                */
#define EDECR 309	/* equiv to ISUBST                */
#define ELOADB 310	/* breg = (Etos)                  */
#define ESTOREB 311	/* (Etos) = breg                  */
#define EINCRB 312	/* breg = breg + (Etos)           */
#define EDECRB 313	/* breg = breg - (Etos)           */
#define ELSHIFT 315	/* (Etos) = (Etos-1) << (Etos)    */
#define ERSHIFT 316	/* (Etos) = (Etos-1) >> (Etos)    */
#define EADJL 317	/* char((Etos-3),(Etos-2))        */
		 	/*   = leftjustify                */
		 	/*      (char((Etos-1),(Etos)))   */
#define EADJR 318	/* char((Etos-3),(Etos-2))        */
		 	/*   = rightjustify               */
		 	/*      (char((Etos-1),(Etos)))   */
#define EVERIFY 319	/* char1 = verify (char2,char3)   */
#define ERBIT 321	/* (Etos) = bit (Etos-1) in (Etos) */
#define EWBIT 322	/* bit(Etos-1) in (Etos) = (Etos-2)*/
#define EMSTORE 323	/* array = scalar                 */
		 	/* (Etos) copies of (Etos-2)      */
		 	/*               at (Etos-1)      */
#define ALLTEMP 324	/* allocate array temp on stack   */
		 	/* (Etos) is size in bytes        */
		 	/* ((Etos-1)) is dope vector(dv)  */
		 	/*  (dv+4) = addr(temp)           */
		 	/*    (dv) = (dv) + addr(temp)    */
#define ALLRES 325	/* allocate array temp on stack   */
		 	/* (Etos) is size in bytes        */
		 	/* ((Etos-1)) is dope vector(dv)  */
		 	/*    (dv) = addr(temp)           */
		 	/* (dv+12) = (dv+12) + addr(temp) */
#define MANTEMPS 326	/* (Etos) = 1  save stackfront    */
		 	/*                  in (Etos-1)   */
		 	/*        = 2  restore stackfront */
		 	/*                from (Etos-1)   */
#define ALLARR 327	/* allocate user array on stack   */
		 	/* (Etos) is size in bytes        */
		 	/* ((Etos-1)) is dope vector(dv)  */
		 	/*  (dv+4) = addr(temp)           */
		 	/*    (dv) = (dv) + addr(temp)    */
#define DEALLARR 328	/* deallocate user array on stack */
		 	/* (Etos) is dope vector          */
		 	/* (dv)=0                         */
#define EMSTOREA 329	/* array = scalar                 */
		 	/* (Etos) copies of (Etos-2) bytes*/
		 	/*               at (Etos-3)      */
		 	/*               to (Etos-1)      */
#define CXCVT 330	/*    reg = ((Etos-1))            */
		 	/* (Etos) = variant<<8            */
		 	/*            ! sizecode(RHS)<<2  */
		 	/*              ! sizecode(LHS)   */
#define VVSUB 331	/* (Etos)=vector valued subscript */
		 	/* (Etos-1)= array                */
#define VCSEDEF 332	/* (Etos)=VCSEVAL describing cse  */
		 	/* (Etos-1)=1 if cse is a vector  */
		 	/*            var or 0 if it is a */
		 	/*            vector expression   */
		 	/* (Etos-2)=vector var/expression */
#define FORCE 333	/* Start of forced expr evaluation*/
		 	/* in register (Etos)             */
#define ENDFORCE 334	/* End of forced expr evaluation  */
		 	/* in register (Etos)             */
#define GATHER 335	/* (Etos)=array                   */
		 	/* (Etos-1)= vector valued subscr */
#define PSEUDONOP 336	/* No operands - mandatory nop's  */
 
#define EIMERGE1 352	/* if                             */
#define ERMERGE1 353	/*    (Etos)                      */
		 	/* then                           */
		 	/*    (Etos-2) => (Etos)          */
		 	/* else                           */
		 	/*    (Etos-1) => (Etos)          */
 
#define EMERGE2 354	/* if                             */
		 	/*    (Etos)                      */
		 	/* then                           */
		 	/*    (Etos-3) => (Etos)          */
		 	/*    (Etos-4) => (Etos-1)        */
		 	/* else                           */
		 	/*    (Etos-1) => (Etos)          */
		 	/*    (Etos-2) => (Etos-1)        */
/**/
/**/
/**/	/**************************************************************************/
/**/	/****** 		   PASCAL specific codes                    *******/
/**/	/**************************************************************************/
#define SETOPTION 512	/* (Etos-1) is a 32-bit mask with */	 
/***/
				/* integer operations */
/***/
#define INMOD 525	/* (Etos-1) mod (Etos) => (Etos)  */
#define UNMOD 526	/* (Etos-1) mod (Etos) => (Etos)  */
#define IMDIV 527	/* (Etos-1) DIV (Etos) => (Etos)  */	/*MODULA*/
/***/
			/* set operations */
/***/
#define SETI 530	/*  (Etos-1) * (Etos) => (Etos)   */
#define SETU 531	/*  (Etos-1) + (Etos) => (Etos)   */
#define SETD 532	/*  (Etos-1) - (Etos) => (Etos)   */
/***/
#define SETLE 533	/*  if                            */
#define SETEQ 534	/*     (Etos-1) <relop> (Etos)    */
#define SETNE 535	/*  then                          */
#define SETIN 536	/*     1 => (Etos)                */
		 	/*  else                          */
		 	/*     0 => (Etos)                */
/***/
#define SETSING 537	/*  [(Etos)] => (Etos)            */
#define SETRANGE 538	/*  [(Etos-1)..(Etos)] => (Etos)  */
#define SETINCL 539	/*DEBUG*/	 
#define SETEXCL 540	/*DEBUG*/	 
#define SETSD 541	/*  (Etos-1) / (Etos) => (Etos)   */	 
/***/
 	/* Pascal-E / Modula string / array operations */
 
#define STRTOCH 544	/* (Etos) = (Etos-1)[1]           */
#define STRPLUS 545	/* str((Etos-3)) + str((Etos-2))  */
		 	/*     => ((Etos-1))              */
#define STRMOVE 546	/* str((Etos-1)) <= str((Etos-2)) */
#define PUSHSTR 547
 
 	/* boolean operations, size one results */
 
#define BAND 552	/* (Etos)  = (Etos-1) & (Etos)    */
#define BOR 553		/* (Etos)  = (Etos-1) ! (Etos)    */
 
 	/* bit field operations */
 
#define UPBITII 560	/*  unpack integer  to integer    */
#define UPBITUU 561	/*  unpack unsigned to unsigned   */
#define UPBITIU 562	/*  unpack integer  to unsigned   */
#define UPBITUI 563	/*  unpack unsigned to integer    */
 
#define INDEXBITS 564	/*  construct packed field        */
		 	/*  descriptor from               */
		 	/*  (@ Etos-2)- array base        */
		 	/*  (Etos-1)  - index value       */
		 	/*  (Etos)    - elements per word */
 
#define SAVEBITREF 565	/* save reference to bit-packed   */
		 	/* record within bit-packed       */
		 	/* structure.                     */
 
#define RESTBITREF 566	/* restore reference to bit-packed*/
		 	/* record within bit-packed       */
		 	/* structure.                     */
 
#define BITADDR 567	/* attempt to give byte address   */
		 	/* of bit field                   */
 
			/* Standard integer procedures */
/***/
#define ISQR 601	/*  fn(Etos)   => (Etos)          */
/***/
			/* Standard real procedures */
/***/
#define RSQR 611	/*  fn(Etos)   => (Etos)          */
/***/
			/* error detection */
/***/
#define CHKRNG 622	/*  if                            */
		 	/*    (Etos-3) < (Etos-2) or      */
		 	/*    (Etos-3) > (Etos-1)         */
		 	/*  then                          */
		 	/*    trap((Etos))                */
		 	/*  else                          */
		 	/*    [(Etos-3)] => [(Etos)]      */
#define CHKXX 623	/*  if (Etos-2) XX (Etos-1)       */
		 	/*  then trap((Etos)>>3)          */
		 	/*  XX = (Etos)&7                 */
#define CHKSETRNG 624	/*  if                            */
		 	/*    min([(Etos-3)]) < (Etos-2)  */
		 	/*  or                            */
		 	/*    max([Etos-3)]) > (Etos-1)   */
		 	/*  then                          */
		 	/*    trap((Etos))                */
		 	/*  else                          */
		 	/*    [(Etos-3)] => [(Etos)]      */
#define RCHKRNG 626	/*  if                            */
		 	/*    (Etos-3) < (Etos-2) or      */
		 	/*    (Etos-3) > (Etos-1)         */
		 	/*  then                          */
		 	/*    trap((Etos))                */
		 	/*  else                          */
		 	/*    [(Etos-3)] => [(Etos)]      */
#define RCHKXX 627	/*  if (Etos-2) XX (Etos-1)       */
		 	/*  then trap((Etos)>>3)          */
		 	/*  XX = (Etos)&7                 */
 
#define UCHKRNG 628	/*  if                            */
		 	/*    (Etos-3) < (Etos-2) or      */
		 	/*    (Etos-3) > (Etos-1)         */
		 	/*  then                          */
		 	/*    trap((Etos))                */
		 	/*  else                          */
		 	/*    [(Etos-3)] => [(Etos)]      */
#define UCHKXX 629	/*  if (Etos-2) XX (Etos-1)       */
		 	/*  then trap((Etos)>>3)          */
		 	/*  XX = (Etos)&7                 */
 
#define CHKUOVF 634	/*  if uns overflow(Etos) Trap    */
#define CHKIOVF 635	/*  if int overflow(Etos) Trap    */
#define CHKROVF 636	/*  if rl overflow(Etos) Trap     */
#define TRAPOVF 639	/*  enable arithmetic exceptions  */
/***/
			/* global goto support */
/***/
#define SAVESTK 616	/*  StackTop => (Etos)            */	 
#define RECOVERSTK 617	/*  (Etos) => StackTop            */	 
/**/
/***************************************************************************/
/**                      C and C++ specific opcodes                       **/
/***************************************************************************/
/**/
#define CMPSTR 768	/* Compare C Strings               */
#define CDUPADD 769	/* (Etos) = (Etos-2) + (Etos-1)    */
		 	/* and (Etos-2) => (Etos)          */
#define CDUPSUB 770	/* (Etos) = (Etos-2) - (Etos-1)    */
#define ECSTORE 771	/* struct((Etos))=struct((Etos-1)) */
#define ECPROCCALL 772	/* call proc thro pointer (Etos)   */
#define EPUSHSTR 773	/* stack stct((Etos-1)),size(Etos) */
#define ELDBITS 774	/* (Etos) = bit field from (Etos-2)*/
		 	/* size   (Etos) bits              */
		 	/* offset (Etos-1) bits            */
#define ESTBITS 775	/* bit field in (Etos) = (Etos-3)  */
		 	/* size   (Etos-1) bits            */
		 	/* offset (Etos-2) bits            */
#define UADDST 776	/* unsigned add to store           */
#define USUBST 777	/* unsigned sub from store         */
#define UMULTST 778	/* unsigned mult to store          */
#define RADDST 780	/* ((Etos-1)) = (Etos-1) + (Etos)  */
#define RSUBST 781	/* ((Etos-1)) = (Etos-1) - (Etos)  */
#define RMULTST 782	/* ((Etos-1)) = (Etos-1) * (Etos)  */
#define RDIVST 783	/* ((Etos-1)) = (Etos-1) / (Etos)  */
#define ISHLST 784	/* ((Etos-1)) = (Etos-1) << (Etos) */
#define ISHRST 785	/* ((Etos-1)) = (Etos-1) >> (Etos) */
#define CEVAL 786	/* force load of (Etos)            */
#define ECSAVE 787	/* replicate (Etos) and save copy  */
#define ECRESTORE 788	/* recover saved operand (FIFO)    */
#define ISHRAST 789	/* shift right arith to store      */
#define CJFALSE 790	/* JFALSE with freeregs            */
#define CJTRUE 791	/* JTRUE with freeregs             */
#define ESTRLEN 792	/* Returns length of string at addr*/
 

/* end of automatic translation */

