Artifact d852803e8eba4ea5d5f82a140bf333d5b3339c65505a109cb9226721c5cee215:

• File psl-1983/3-1/comp/comp-decls.red — part of check-in [eb17ceb7f6] at 2020-04-21 19:40:01 on branch master — Add Reduce 3.0 to the historical section of the archive, and some more
  files relating to version sof PSL from the early 1980s. Thanks are due to
  Paul McJones and Nelson Beebe for these, as well as to all the original
  authors.

  git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/historical@5328 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 14587) [annotate] [blame] [check-ins using] [more...]

• File psl-1983/comp/comp-decls.red — part of check-in [eb17ceb7f6] at 2020-04-21 19:40:01 on branch master — Add Reduce 3.0 to the historical section of the archive, and some more
  files relating to version sof PSL from the early 1980s. Thanks are due to
  Paul McJones and Nelson Beebe for these, as well as to all the original
  authors.

  git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/historical@5328 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 14587) [annotate] [blame] [check-ins using]

%
% COMP-DECLS.RED - Machine-independent declaractions used by the compiler
% 
% Author:      Eric Benson
%	       Symbolic Computation Group
%              Computer Science Dept.
%              University of Utah
% Date:        16 October 1981
% Copyright (c) 1981 University of Utah
%
%  <PSL.COMP>COMP-DECLS.RED.16,  3-Sep-82 09:46:43, Edit by BENSON
%  Added PA1REFORMFN for WNOT
%  <PSL.COMP>COMP-DECLS.RED.5,   3-Dec-82 18:20:08, Edit by PERDUE
%  Removed PA1REFORMFN for NE
%  <PSL.COMP>COMP-DECLS.RED.6,  24-Jan-83 16:04:00, Edit by MLGriss
%  Changed W to !%!%!%W in the EQCAR to avoid subst W into EQCAR form

%  Pass 1 functions

put('Apply,	'PA1FN,		'!&PaApply);
PUT('ASSOC,	'PA1FN,		'!&PAASSOC);
PUT('EQUAL,	'PA1FN,		'!&PAEQUAL);
PUT('MEMBER,	'PA1FN,		'!&PAMEMBER);
put('Catch,	'Pa1Fn,		'!&PaCatch);
PUT('COND,	'PA1FN,		'!&PACOND);
PUT('DIFFERENCE,'PA1FN,		'!&PADIFF);
PUT('FUNCTION,	'PA1FN,		'!&PAFUNCTION);
PUT('GETMEM,	'PA1FN,		'!&PAGETMEM);
PUT('GO,	'PA1FN,		'!&PAIDENT);
PUT('CASE,	'PA1FN,		'!&PACASE);
PUT('INTERN,	'PA1FN,		'!&PAINTERN);
PUT('LAMBDA,	'PA1FN,		'!&PALAMBDA);
PUT('LESSP,	'PA1FN,		'!&PALESSP);
PUT('LIST,	'PA1FN,		'!&PALIST);
PUT('LOC,	'PA1REFORMFN,	'!&REFORMLOC);
PUT('MAP,	'PA1FN,		'!&PAMAP);
PUT('MAPC,	'PA1FN,		'!&PAMAPC);
PUT('MAPCAN,	'PA1FN,		'!&PAMAPCAN);
PUT('MAPCAR,	'PA1FN,		'!&PAMAPCAR);
PUT('MAPCON,	'PA1FN,		'!&PAMAPCON);
PUT('MAPLIST,	'PA1FN,		'!&PAMAPLIST);
PUT('MINUS,	'PA1FN,		'!&PAMINUS);
PUT('NULL,	'PA1REFORMFN,	'!&REFORMNULL);
% PUT('NE,	'PA1REFORMFN,	'!&REFORMNE);		% Perdue 12/3/82
put('Nth,	'Pa1Fn,		'!&PaNth);
put('PNth,	'Pa1Fn,		'!&PaPNth);
PUT('PLUS2,	'PA1FN,		'!&PAPLUS2);
PUT('PROG,	'PA1FN,		'!&PAPROG);
PUT('PUTMEM,	'PA1FN,		'!&PAPUTMEM);
PUT('PUTLISPVAR,'PA1FN,		'!&PAPUTLISPVAR);
PUT('LISPVAR,	'PA1FN,		'!&PALISPVAR);
PUT('QUOTE,	'PA1FN,		'!&PAIDENT);
PUT('WCONST,	'PA1FN,		'!&PAWCONST);
PUT('SETQ,	'PA1FN,		'!&PASETQ);
PUT('WPLUS2,	'PA1FN,		'!&GROUP);
PUT('WDIFFERENCE,'PA1FN,	'!&GROUP);
PUT('WMINUS,	'PA1FN,		'!&GROUP);
PUT('WTIMES2,	'PA1FN,		'!&ASSOCOP);
PUT('WAND,	'PA1FN,		'!&ASSOCOP);
PUT('WOR,	'PA1FN,		'!&ASSOCOP);
PUT('WXOR,	'PA1FN,		'!&ASSOCOP);
PUT('WPLUS2,	'PA1ALGFN,		'!&GROUPV);
PUT('WDIFFERENCE,'PA1ALGFN,	'!&GROUPV);
PUT('WMINUS,	'PA1ALGFN,		'!&GROUPV);
PUT('WTIMES2,	'PA1ALGFN,		'!&ASSOCOPV);
PUT('WAND,	'PA1ALGFN,		'!&ASSOCOPV);
PUT('WOR,	'PA1ALGFN,		'!&ASSOCOPV);
PUT('WXOR,	'PA1ALGFN,		'!&ASSOCOPV);
PUT('WSHIFT,	'PA1REFORMFN,	'!&DOOP);
PUT('WNOT,	'PA1REFORMFN,	'!&DOOP);
put('WTimes2,	'PA1Reformfn,	function !&PaReformWTimes2);

% Simplification
PUT('WPLUS2,	'DOFN,		'PLUS2);
PUT('WDIFFERENCE,'DOFN,		'DIFFERENCE);
PUT('WMINUS,	'DOFN,		'MINUS);
PUT('WTIMES2,	'DOFN,		'TIMES2);
PUT('WQUOTIENT,	'DOFN,		'QUOTIENT);
PUT('WREMAINDER,'DOFN,		'REMAINDER);
PUT('WAND,	'DOFN,		'LAND);
PUT('WOR,	'DOFN,		'LOR);
PUT('WXOR,	'DOFN,		'LXOR);
PUT('WNOT,	'DOFN,		'LNOT);
PUT('WSHIFT,	'DOFN,		'LSHIFT);

PUT('WTIMES2,	'ONE,		1);
PUT('WTIMES2,	'ZERO,		0);
PUT('WPLUS2,	'ONE,		0);
PUT('WPLUS2,	'GROUPOPS,	'(WPLUS2 WDIFFERENCE WMINUS));
PUT('WMINUS,	'GROUPOPS,	'(WPLUS2 WDIFFERENCE WMINUS));
PUT('WDIFFERENCE,'GROUPOPS,	'(WPLUS2 WDIFFERENCE WMINUS));
PUT('WAND,	'ZERO,		0);
PUT('WOR,	'ONE,		0);
PUT('WXOR,	'ONE,		0);

% Compile functions

PUT('AND,	'COMPFN,	'!&COMANDOR);
PUT('APPLY,	'COMPFN,	'!&COMAPPLY);
PUT('COND,	'COMPFN,	'!&COMCOND);
PUT('CONS,	'COMPFN,	'!&COMCONS);
PUT('GO,	'COMPFN,	'!&COMGO);
PUT('CASE,	'COMPFN,	'!&COMCASE);
PUT('OR,	'COMPFN,	'!&COMANDOR);
PUT('PROG,	'COMPFN,	'!&COMPROG);
PUT('PROG2,	'COMPFN,	'!&COMPROGN);
PUT('PROGN,	'COMPFN,	'!&COMPROGN);
PUT('RETURN,	'COMPFN,	'!&COMRETURN);

% Patterns for the tests and SETQ

PUT('EQ,	'OPENTST,	'(TSTPAT !*JUMPEQ));
PUT('EQ,	'OPENFN,	'(TVPAT !*JUMPEQ));
PUT('NE,	'OPENTST,	'(TSTPAT !*JUMPNOTEQ));
PUT('NE,	'OPENFN,	'(TVPAT !*JUMPNOTEQ));
PUT('AND,	'OPENTST,	'!&TSTANDOR);
PUT('OR,	'OPENTST,	'!&TSTANDOR);
PUT('PAIRP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE PAIR));
PUT('ATOM,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE PAIR));
PUT('STRINGP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE STR));
PUT('NOTSTRINGP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE STR));
PUT('VECTORP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE VECT));
PUT('NOTVECTORP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE VECT));
PUT('CODEP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE CODE));
PUT('NOTCODEP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE CODE));
PUT('FLOATP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE FLTN));
PUT('NOTFLOATP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE FLTN));
PUT('INTP,	'OPENTST,	'(TSTPAT2 !*JUMPINTYPE POSINT));
PUT('NOTINTP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTINTYPE POSINT));
PUT('FIXP,	'OPENTST,	'(TSTPAT2 !*JUMPINTYPE BIGN));
PUT('NOTFIXP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTINTYPE BIGN));
PUT('NUMBERP,	'OPENTST,	'(TSTPAT2 !*JUMPINTYPE FLTN));
PUT('NOTNUMBERP,'OPENTST,	'(TSTPAT2 !*JUMPNOTINTYPE FLTN));
PUT('FIXNP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE FIXN));
PUT('NOTFIXNP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE FIXN));
PUT('BIGP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE BIGN));
PUT('NOTBIGP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE BIGN));
PUT('POSINTP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE POSINT));
PUT('NOTPOSINTP,'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE POSINT));
PUT('NEGINTP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE NEGINT));
PUT('NOTNEGINTP,'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE NEGINT));
PUT('IDP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE ID));
PUT('NOTIDP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE ID));
PUT('BYTESP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE BYTES));
PUT('NOTBYTESP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE BYTES));
PUT('WRDSP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE WRDS));
PUT('NOTWRDSP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE WRDS));
PUT('HALFWORDSP,	'OPENTST,	'(TSTPAT2 !*JUMPTYPE HALFWORDS));
PUT('NOTHALFWORDSP,	'OPENTST,	'(TSTPAT2 !*JUMPNOTTYPE HALFWORDS));
PUT('PAIRP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE PAIR));
PUT('ATOM,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE PAIR));
PUT('STRINGP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE STR));
PUT('NOTSTRINGP,'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE STR));
PUT('VECTORP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE VECT));
PUT('NOTVECTORP,'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE VECT));
PUT('CODEP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE CODE));
PUT('NOTCODEP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE CODE));
PUT('FLOATP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE FLTN));
PUT('NOTFLOATP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE FLTN));
PUT('INTP,	'OPENFN,	'(TVPAT1 !*JUMPINTYPE POSINT));
PUT('NOTINTP,	'OPENFN,	'(TVPAT1 !*JUMPNOTINTYPE POSINT));
PUT('FIXP,	'OPENFN,	'(TVPAT1 !*JUMPINTYPE BIGN));
PUT('NOTFIXP,	'OPENFN,	'(TVPAT1 !*JUMPNOTINTYPE BIGN));
PUT('NUMBERP,	'OPENFN,	'(TVPAT1 !*JUMPINTYPE FLTN));
PUT('NOTNUMBERP,'OPENFN,	'(TVPAT1 !*JUMPNOTINTYPE FLTN));
PUT('FIXNP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE FIXN));
PUT('NOTFIXNP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE FIXN));
PUT('BIGP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE BIGN));
PUT('NOTBIGP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE BIGN));
PUT('POSINTP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE POSINT));
PUT('NOTPOSINTP,'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE POSINT));
PUT('NEGINTP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE NEGINT));
PUT('NOTNEGINTP,'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE NEGINT));
PUT('IDP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE ID));
PUT('NOTIDP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE ID));
PUT('BYTESP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE BYTES));
PUT('NOTBYTESP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE BYTES));
PUT('WRDSP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE WRDS));
PUT('NOTWRDSP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE WRDS));
PUT('HALFWORDSP,	'OPENFN,	'(TVPAT1 !*JUMPTYPE HALFWORDS));
PUT('NOTHALFWORDSP,	'OPENFN,	'(TVPAT1 !*JUMPNOTTYPE HALFWORDS));
PUT('SETQ,	'OPENFN,	'(SETQPAT NIL));
PUT('RPLACA,	'OPENFN,	'(RPLACPAT CAR));
PUT('RPLACD,	'OPENFN,	'(RPLACPAT CDR));
PUT('WPLUS2,	'OPENFN,	'(ASSOCPAT !*WPLUS2));
PUT('WDIFFERENCE,'OPENFN,	'(SUBPAT !*WDIFFERENCE));
PUT('WTIMES2,	'OPENFN,	'(ASSOCPAT !*WTIMES2));
PUT('WMINUS,	'OPENFN,	'(UNARYPAT !*WMINUS));
PUT('WAND,	'OPENFN,	'(ASSOCPAT !*WAND));
PUT('WOR,	'OPENFN,	'(ASSOCPAT !*WOR));
PUT('WXOR,	'OPENFN,	'(ASSOCPAT !*WXOR));
PUT('WNOT,	'OPENFN,	'(UNARYPAT !*WNOT));
PUT('WSHIFT,	'OPENFN,	'(NONASSOCPAT !*WSHIFT));
PUT('MKITEMREV,	'OPENFN,	'(NONASSOCPAT !*MKITEM));
PUT('LOC,	'OPENFN,	'(UNARYPAT !*LOC));
PUT('!*ADDMEM,	'OPENFN,	'(MODMEMPAT !*ADDMEM));
PUT('!*MPYMEM,	'OPENFN,	'(MODMEMPAT !*MPYMEM));
PUT('FIELD,	'OPENFN,	'(FIELDPAT !*FIELD));
PUT('SIGNEDFIELD,'OPENFN,	'(FIELDPAT !*SIGNEDFIELD));
PUT('PUTFIELDREV,'OPENFN,	'(PUTFIELDPAT !*PUTFIELD));
PUT('WGREATERP,'OPENTST,	'(TSTPATC !*JUMPWGREATERP !*JUMPWLESSP));
PUT('WLEQ,	'OPENTST,	'(TSTPATC !*JUMPWLEQ !*JUMPWGEQ));
PUT('WGEQ,	'OPENTST,	'(TSTPATC !*JUMPWGEQ !*JUMPWLEQ));
PUT('WLESSP,	'OPENTST,	'(TSTPATC !*JUMPWLESSP !*JUMPWGREATERP));
PUT('WGREATERP,	'OPENFN,	'(TVPAT !*JUMPWGREATERP));
PUT('WLEQ,	'OPENFN,	'(TVPAT !*JUMPWLEQ));
PUT('WGEQ,	'OPENFN,	'(TVPAT !*JUMPWGEQ));
PUT('WLESSP,	'OPENFN,	'(TVPAT !*JUMPWLESSP));

PUT('EQ,'FLIPTST,'NE);
PUT('NE,'FLIPTST,'EQ);
PUT('ATOM,'FLIPTST,'PAIRP);
PUT('PAIRP,'FLIPTST,'ATOM);
PUT('STRINGP,'FLIPTST,'NOTSTRINGP);
PUT('NOTSTRINGP,'FLIPTST,'STRINGP);
PUT('BytesP,'FLIPTST,'NOTBytesP);
PUT('NOTBytesP,'FLIPTST,'BytesP);
PUT('WrdsP,'FLIPTST,'NOTWrdsP);
PUT('NOTWrdsP,'FLIPTST,'WrdsP);
PUT('HalfwordsP,'FLIPTST,'NOTHalfwordsP);
PUT('NOTHalfwordsP,'FLIPTST,'HalfwordsP);
PUT('CODEP,'FLIPTST,'NOTCODEP);
PUT('NOTCODEP, 'FLIPTST,'CODEP);
PUT('IDP,'FLIPTST,'NOTIDP);
PUT('NOTIDP,'FLIPTST,'IDP);
PUT('INTP,'FLIPTST,'NOTINTP);
PUT('NOTINTP,'FLIPTST,'INTP);
PUT('POSINTP,'FLIPTST,'NOTPOSINTP);
PUT('NOTPOSINTP,'FLIPTST,'POSINTP);
PUT('NEGINTP,'FLIPTST,'NOTNEGINTP);
PUT('NOTNEGINTP,'FLIPTST,'NEGINTP);
PUT('FIXP,'FLIPTST,'NOTFIXP);
PUT('NOTFIXP,'FLIPTST,'FIXP);
PUT('NUMBERP,'FLIPTST,'NOTNUMBERP);
PUT('NOTNUMBERP,'FLIPTST,'NUMBERP);
PUT('FIXNP,'FLIPTST,'NOTFIXNP);
PUT('NOTFIXNP,'FLIPTST,'FIXNP);
PUT('FLOATP,'FLIPTST,'NOTFLOATP);
PUT('NOTFLOATP,'FLIPTST,'FLOATP);
PUT('BIGP,'FLIPTST,'NOTBIGP);
PUT('NOTBIGP,'FLIPTST,'BIGP);
PUT('VECTORP,'FLIPTST,'NOTVECTORP);
PUT('NOTVECTORP,'FLIPTST,'VECTORP);
PUT('WLESSP,'FLIPTST,'WGEQ);
PUT('WGEQ,'FLIPTST,'WLESSP);
PUT('WLEQ,'FLIPTST,'WGREATERP);
PUT('WGREATERP,'FLIPTST,'WLEQ);

% Match functions

PUT('ANY,'MATCHFN,'!&ANY);
PUT('VAR,'MATCHFN,'!&VAR);
PUT('REG,'MATCHFN,'!&REGFP);
PUT('DEST,'MATCHFN,'!&DEST);
PUT('USESDEST,'MATCHFN,'!&USESDEST);
PUT('REGN,'MATCHFN,'!&REGN);
PUT('NOTDEST,'MATCHFN,'!&NOTDEST);
PUT('NOTANYREG,'MATCHFN,'!&NOTANYREG);
PUT('MEM,'MATCHFN,'!&MEM);
PUT('ANYREGFN,'MATCHFN,'!&ANYREGFNP);

% Tag properties

FLAG('(!$LOCAL !$GLOBAL !$FLUID QUOTE WCONST IDLOC WVAR
       REG LABEL FRAME !*FRAMESIZE IREG),
	'TERMINAL);
FLAG('(!$LOCAL !$GLOBAL !$FLUID WVAR),'VAR);
FLAG('(QUOTE WCONST IDLOC FRAMESIZE),'CONST);
FLAG('(REG),'REG);
FLAG('(!$FLUID !$GLOBAL),'EXTVAR);
FLAG('(CAR CDR !$NAME MEMORY FRAMESIZE), 'ANYREG);

FLAG('(!*ADDMEM !*MPYMEM),'MEMMOD);

% Optimizing functions

PUT('!*LBL,	'OPTFN,	'!&LBLOPT);
PUT('!*MOVE,	'OPTFN,	'!&STOPT);
PUT('!*JUMP,	'OPTFN,	'!&JUMPOPT);		

% Things which can be compiled

FLAG('(EXPR FEXPR MACRO NEXPR),'COMPILE);

% Some compiler macros

DEFLIST('((CAAR (LAMBDA (U) (CAR (CAR U))))
          (CADR (LAMBDA (U) (CAR (CDR U))))
          (CDAR (LAMBDA (U) (CDR (CAR U))))
          (CDDR (LAMBDA (U) (CDR (CDR U))))
          (CAAAR (LAMBDA (U) (CAR (CAR (CAR U)))))
          (CAADR (LAMBDA (U) (CAR (CAR (CDR U)))))
          (CADAR (LAMBDA (U) (CAR (CDR (CAR U)))))
          (CADDR (LAMBDA (U) (CAR (CDR (CDR U)))))
          (CDAAR (LAMBDA (U) (CDR (CAR (CAR U)))))
          (CDADR (LAMBDA (U) (CDR (CAR (CDR U)))))
          (CDDAR (LAMBDA (U) (CDR (CDR (CAR U)))))
          (CDDDR (LAMBDA (U) (CDR (CDR (CDR U)))))
	  (EQCAR (LAMBDA (U V)
		 ((LAMBDA (!%!%!%W) (AND (PAIRP !%!%!%W) 
				         (EQ (CAR !%!%!%W) V))) U)))
	  (CONSTANTP (LAMBDA (U)
			     ((LAMBDA (V) (NOT (OR (PAIRP V) (IDP V))))
			      U)))
	  (WEQ (LAMBDA (U V) (EQ U V)))
	  (WNEQ (LAMBDA (U V) (NE U V)))
	  (IPLUS2 (LAMBDA (U V) (WPLUS2 U V)))
	  (IADD1 (LAMBDA (U) (WPLUS2 U 1)))
	  (IDIFFERENCE (LAMBDA (U V) (WDIFFERENCE U V)))
	  (ISUB1 (LAMBDA (U) (WDIFFERENCE U 1)))
	  (ITIMES2 (LAMBDA (U V) (WTIMES2 U V)))
	  (IQUOTIENT (LAMBDA (U V) (WQUOTIENT U V)))
	  (IREMAINDER (LAMBDA (U V) (WREMAINDER U V)))
	  (IGREATERP (LAMBDA (U V) (WGREATERP U V)))
	  (ILESSP (LAMBDA (U V) (WLESSP U V)))
	  (ILEQ (LAMBDA (U V) (WLEQ U V)))
	  (IGEQ (LAMBDA (U V) (WGEQ U V)))
	  (ILOR (LAMBDA (U V) (WOR U V)))
	  (ILSH (LAMBDA (U V) (WSHIFT U V)))
	  (ILAND (LAMBDA (U V) (WAND U V)))
	  (ILXOR (LAMBDA (U V) (WXOR U V)))
	  (IZEROP (LAMBDA (U) (EQ U 0)))
	  (IONEP (LAMBDA (U) (EQ U 1)))
	  (IMINUSP (LAMBDA (U) (WLESSP U 0)))
	  (IMINUS (LAMBDA (U) (WMINUS U)))
	  (PUTFIELD (LAMBDA (U V W X) (PUTFIELDREV X U V W)))
	  (MKITEM (LAMBDA (U V) (MKITEMREV V U)))
	  (NEQ (LAMBDA (U V) (NOT (EQUAL U V))))
	  (GEQ (LAMBDA (U V) (NOT (LESSP U V))))
	  (LEQ (LAMBDA (U V) (NOT (GREATERP U V))))
          (NOT (LAMBDA (U) (NULL U)))),'CMACRO);

% Macro functions

PUT('A1,'SUBSTFN,'!&ARG1);
PUT('A2,'SUBSTFN,'!&ARG2);
PUT('A3,'SUBSTFN,'!&ARG3);
PUT('A4,'SUBSTFN,'!&ARG4);
PUT('FN,'SUBSTFN,'!&PARAM1);
PUT('MAC,'SUBSTFN,'!&PARAM2);
PUT('P2,'SUBSTFN,'!&PARAM3);
PUT('P3,'SUBSTFN,'!&PARAM4);
PUT('T1,'SUBSTFN,'!&GETTEMP);
PUT('T2,'SUBSTFN,'!&GETTEMP);
PUT('T3,'SUBSTFN,'!&GETTEMP);
PUT('T4,'SUBSTFN,'!&GETTEMP);
PUT('L1,'SUBSTFN,'!&GETTEMPLBL);
PUT('L2,'SUBSTFN,'!&GETTEMPLBL);
PUT('L3,'SUBSTFN,'!&GETTEMPLBL);
PUT('L4,'SUBSTFN,'!&GETTEMPLBL);

% Emit functions

PUT('!*LOAD,'EMITFN,'!&EMITLOAD);
PUT('!*STORE,'EMITFN,'!&EMITSTORE);
PUT('!*JUMP,'EMITFN,'!&EMITJUMP);
PUT('!*LBL,'EMITFN,'!&EMITLBL);
PUT('!*ADDMEM,'EMITFN,'!&EMITMEMMOD);
PUT('!*MPYMEM,'EMITFN,'!&EMITMEMMOD);
PUT('!*ADDMEM, 'UNMEMMOD, '!*WPLUS2);
PUT('!*MPYMEM, 'UNMEMMOD, '!*WTIMES2);

% In memory operations

PUT('WPLUS2,'MEMMODFN,'!*ADDMEM);
PUT('WTIMES2,'MEMMODFN,'!*MPYMEM);

% Flip jump for conditional jump macros

PUT('!*JUMPEQ,'NEGJMP,'!*JUMPNOTEQ);
PUT('!*JUMPNOTEQ,'NEGJMP,'!*JUMPEQ);
PUT('!*JUMPTYPE,'NEGJMP,'!*JUMPNOTTYPE);
PUT('!*JUMPNOTTYPE,'NEGJMP,'!*JUMPTYPE);
PUT('!*JUMPINTYPE,'NEGJMP,'!*JUMPNOTINTYPE);
PUT('!*JUMPNOTINTYPE,'NEGJMP,'!*JUMPINTYPE);
PUT('!*JUMPWEQ,'NEGJMP,'!*JUMPWNEQ);
PUT('!*JUMPWNEQ,'NEGJMP,'!*JUMPWEQ);
PUT('!*JUMPWLESSP,'NEGJMP,'!*JUMPWGEQ);
PUT('!*JUMPWGEQ,'NEGJMP,'!*JUMPWLESSP);
PUT('!*JUMPWLEQ,'NEGJMP,'!*JUMPWGREATERP);
PUT('!*JUMPWGREATERP,'NEGJMP,'!*JUMPWLEQ);

% Assorted other flags

FLAG('(!*JUMP !*LINKE !*EXIT),'TRANSFER);
FLAG('(!*LINK !*LINKE),'UNKNOWNUSE);
PUT('!*LINK, 'EXITING, '!*LINKE);

% Initialize variables
!*MSG := T;				% Do print messages
!*INSTALLDESTROY := NIL;
!*USINGDESTROY := T;
!*SHOWDEST := NIL;
!*NOFRAMEFLUID := T;
!*USEREGFLUID := NIL;
!*NOLINKE := NIL;       %. Permit LINKE
!*ORD := NIL;		%. Dont force ORDER
!*R2I := T;		%. Do convert Rec to Iter
GLOBALGENSYM!&:=LIST GENSYM();	 % initialize symbol list
MAXNARGS!&:=15;
LASTACTUALREG!& := 5;

END;