Google
 

Trailing-Edge - PDP-10 Archives - bb-d868c-bm_tops20_v4_2020_distr - language-sources/sn1n.bli
There are 18 other files named sn1n.bli in the archive. Click here to see a list.
!THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
!  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
!
!COPYRIGHT (C) 1972,1973,1974,1977,1978 DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. 01754
!FILENAME:	H1SYNT.BLI
!DATE:		10 JANUARY 74	MGM/FLD/KR


!  REVISION HISTORY  :
!
!  12-28-77 ROUTINES UPLEVELCHECK,IDCHECKER,SSPUNOP,SSPLF,
!           SML ARE MODIFIED AND SYMVALUE OWN VARIABLE IS ADDED
!	    TO FIX BUG#4.
!
!  12-27-77 ROUTINE UPLEVELCHECK IS ADDED TO CHECK REGISTER
!	    DECLARATIONS AND USAGES INSIDE ROUTINES AND IMBEDDED
!	    ROUTINES (GLOBAL ALSO). REPLACE REGISTER LEXEME BY
!	    REGISTER VALUE IF VALID IN A CONTEXT.
!
!  12-21-77 ROUTINE IDCHECKER IS MODIFIED TO FIX BUG#4.
!	    NESTED GLOBAL ROUTINES DECLARING REGISTERS WITH SAME
!	    NAME.
!
!  9-19-77 ROUTINE CONSTCASE,SIF ARE MODIFIED
!          TO FIX BUG#46,NESTED IF EXPRESSIONS OR CASE EXPR.
!
!  7-15-77  ROUTINE FIXBADEXP IS MODIFIED SO THAT AN UNDEFINED
!           SYMBOL IN A BLOCK IS TREATED AS AN EXTERNAL AFTER
!           GIVING FIRST WARNING MESSAGE.THIS WILL NOT GIVE ANYMORE
!           MESSAGE FOR THIS SYMBOL IN THIS BLOCK WHEREEVER USED.
!           THIS WILL ELIMINATE LOTS OF ERROR MESSAGES AND NOTIFIES
!           THE USER ONCE ONLY.
!    6-2-77     ROUTINE SCOMPOUND IS MODIFIED SO THAT NO LOCALS
!	        ARE ADDED AND SUBTRACTED AT BLOCK LEVEL.IT DONE
!	        ONLY AT THE BEGINING OF ROUTINE ENTRY AND EXIT.
!	        IF LOCALS ARE DEFINED AT MODULE LEVEL AND NO ROUTINES
!	        INT THAT MODULE ,IT IS SAME AS OLD METHOD.
!	        THIS WILL NOT CLOBBER STACK FOR LOCALS AND PUSH.
!
!   5-27-77     MACRO CLOSEBR IS MODIFIED TO FIX BUG#11 IN
!	        BLISS10.DOC.THIS RECOGNIZES THE CASE X[]_.X[] +1.
!	        IT SETS A FLAG TO BE USED IN GTGOTM IN GT1.BLI.
!
!    5-16-77	FIX ROUTINE SSPLF TO CALL FIXSIDEEFFECTS FOR
!		CHARACTER HANDLING SPECIAL FUNCTIONS.  FIXES
!		BUG 30.
!
!    5-15-77	FIX ROUTINE SUSERCALL AND SCOMPOUND TO ALLOW
!		THE LATTER TO KEEP TRACK OF THE NUMBER OF ACTUAL
!		ARGUMENTS THAT ARE ON THE STACK WHEN A BLOCK
!		IS PROCESSED.  LOCALS IN SUCH A BLOCK USED TO
!		OVERWRITE ACTUAL ARGUMENTS ALREADY PUSHED ON THE
!		STACK.  FIXES BUG 26.
!
!   5-9-77   ROUTINE SPLIT CALLS SPLIT1.THE CHANGE IS DUE TO
!            OWN OR GLOBAL INITIALIZATION.THEY ARE HANDLED AS
!            PLITS IN SOME SENSE.SPLIT1 IS MODIFIED TO DO THIS.
!            ROUTINE TUPLEITEM AND SUSERCALL WERE MODIFIED TO FIX
!             BUGS REPLICATION COUNT LSS 0 AND LAST ARGUMENT 
!             OF A ROUTINE CALL IN A STRUCTURE.
!	      ROUTINE SPLIT1 IS SAME AS SPLIT EXCEPT FEW CHANGES.
!
%%
%
		F I X E S

	5.200.2 - IN SPTR, CAUSES A NON ZERO TO BE LEFT
		  IN SYM, CORRECTING THE BUG
		  WHERE A<> IS COMPILED UNDER /X (CODETOG=0)


		  FIXBADEXP ADDED TO TEST FOR UNDECLARED NAMES
		  AND FOR STRUCTURE, LINKAGE, LABEL NAMES
		  APPEARING IN EXPRESSIONS.
%
%%
%3.40%	GLOBAL BIND H1SYV=4;	!MODULE VERSION NUMBER
!                   SYNTAX ANALYSIS ROUTINES
!             ---------------------------------------




! FORWARD REFERENCE DECLARATIONS
!--------------------------------

OWN SYMVALUE;	%SYM VALUE IS RETURNED. USED IN UPLEVELCHECK,SML,SSPLF,SSPUNOP AND FIX BUG#4 DEC-28-77 %
FORWARD  SCOMPOUND,SOPERATOR,SML;







! INIT CODE FOR SYNTAX
!----------------------


%3.1%	GLOBAL ROUTINE INITSYNTAX=
	( ERRORFOUND_ERRLEVEL_0; HRUND(); HRUND());
! BOOLEAN PREDICATES AND SMALL MISC. SERVICE ROUTINES
!-----------------------------------------------------


ROUTINE SEFOLLOWS=
	(.DEL<26,1> AND (IF .SYM EQL HEMPTY THEN
			NOT(.DEL<25,1>) ELSE .DEL<25,1>));

ROUTINE AEFOLLOWS=
	(.DEL<24,1> AND (IF .SYM EQL HEMPTY THEN
			NOT(.DEL<25,1>) ELSE .DEL<25,1>));

ROUTINE  FUTAE=
	(.FUTDEL<24,1> AND ( IF .FUTSYM EQL HEMPTY THEN
			NOT(.FUTDEL<25,1>) ELSE .FUTDEL<25,1>));

ROUTINE CORRECTP1=
	BEGIN
	.FUTSYM EQL HEMPTY AND
		(.FUTDEL<HCLASS> EQL CLOBRAC OR .FUTDEL<HCLASS> EQL OPRTR
		OR .FUTDEL<LEFTHALF> EQL HPAROPEN
                OR .FUTDEL<LEFTHALF> EQL HSQOPEN
		OR .FUTDEL<LEFTHALF> EQL HPTOPEN)
	END;

ROUTINE HDELCLASS=
	(IF .DEL<HCLASS> EQL 1 THEN SOPERATOR() ELSE (@DEL)());


ROUTINE SUCCESSIVERELATIONALS(OP)=
	(.OP<HPRIORITY> EQL #30  AND  .DEL<HPRIORITY> EQL #30);


ROUTINE FIXBADEXP=
	IF BADEXPTYPE^(-.ST[.SYM<STEF>,0]<TYPEF>)
	THEN (
		EMESSAGE("ERROR"," FOR ","THE S","YMBOL"," :   ",5);
		EOSTN(.SYM<STEF>);
		ENEWLINE();
                !MAKE UNDEFINED SYMBOLS AS EXTERNAL IN A BLOCK  6-21-77
                ! GIVE WARNINGS ONCE ONLY FOR A SYMBOL IN A BLOCK
		WARNEM(.NSYM,
		IF .ST[.SYM<STEF>,0]<TYPEF> EQL UNDEDT
                THEN (ST[.SYM<STEF>,0]<TYPEF>_EXTRNT;#437)
		 ELSE ERRBADSYM);
		SYM_ZERO);


ROUTINE NOERRORS=(.ERRORFOUND EQL 0);

ROUTINE SHUTOFFCODE= CODETOG_.CODETOG^1;

ROUTINE TURNONCODE= IF .CODETOG NEQ 0 THEN CODETOG_.CODETOG^(-1);

ROUTINE FIXFUTDEL=
    IF .FUTSYM EQL HEMPTY THEN
	BEGIN
	IF .FUTDEL<LEFTHALF> EQL HMIN THEN
	    (FUTDEL_NGNEG<0,0>; FUTDEL<LEFTHALF>_HNEG) ELSE
	IF .FUTDEL<LEFTHALF> EQL HPLUS THEN
	    (LOCAL A,B; A_.SYM; B_.DEL; WRUND(1);
		SYM_.A; DEL_.B) ELSE
	0
	END;
! SYNTAX ERROR REPORTING AND RECOVERY ROUTINES
!----------------------------------------------

%3.1%	GLOBAL ROUTINE RECOVER(POSN,M) =
BEGIN	!
	!  THIS ROUTINE IS CALLED TO REPORT AN ERROR AND RECOVER TO
	! A SENSIBLE POINT --- WHERE SENSIBLE IS DEFINED TO BE ANY
	! UNMATCHED CLOSE BRACKET. ANY OPEN BRACKET SEEN ALONG THE
	! WAY TO OUR UNMATCHED CLOSE IS USED TO TRIGGER SYNTAX ANALYSIS
	! OF ITS INTERIOR.
	!
	ERROR(.POSN,.M);
	!IF CALLED WITH _ IN DEL, WE LOOP FOREVER UNLESS WE MOVE
	!THE WINDOW BEFORE ENTERING THE UNIL LOOP
	IF .DEL <LEFTHALF> EQL HSTO THEN HRUND();
	UNTIL .DEL<LEFTHALF> EQL HSTO OR .DEL<HCLASS> EQL CLOBRAC DO
	BEGIN IF .DEL<HCLASS> EQL OPENBRACKET AND .DEL<ADDRESSF> NEQ 0
		THEN    BEGIN
			ERRLEVEL_0;
                        (.DEL)();
			ERRLEVEL_1
			END
		ELSE HRUND()
	END 
END;
	


ROUTINE DEMAND(PPOSN,ERR,TYPE)=
	BEGIN
	!
	!  THIS ROUTINE IS SIMILAR TO RECOVER IN THAT IT REPORTS
	!  AN ERROR THEN ATTEMPTS TO SCAN AHEAD AND RECOVER. IT 
	!  DIFFERS IN THAT ONLY CERTAIN TYPES OF CLOSING DELIMITERS
	!  ARE ACCEPTABLE.  THE ROUTINE IS CALLED ONLY FROM SPECIFIED
	!  "DEMAND RECOVERY" POINTS -- EG. COMPOUND STMTS.
	!
	DO (HRUND(); RECOVER(.PPOSN,.ERR)) UNTIL
	    CASE .TYPE OF
		SET
		%0% .DEL<LEFTHALF> EQL HSEMCOL  OR  .DEL<LEFTHALF> EQL HROCLO;
		%1% .DEL<LEFTHALF> EQL HSEMCOL  OR  .DEL<LEFTHALF> EQL HEND;
		TES
	END;


	ROUTINE UPLEVELCHECK(XXX)=
	BEGIN
	% XXX - ST POINTER OF REGISTER LEXEME.
	  SYMVALUE - REGISTER NAME IS RETURNED.
	  RETURNS REGISTER NAME IF THE REGISTER USAGE IS VALID IN
		A CONTEXT.
	  DEC-27-1977
	%
	LOCAL STVEC TEMP;
		TEMP=.XXX<STEF>;
		IF .TEMP[0]<TYPEF> EQL REGT THEN
		  BEGIN
		  IF .TGRBLEVEL GEQ .TEMP[0]<BLF> AND .FCNSTATE EQL 3
		    THEN ERROR(.NSYM,#40)
		    ELSE
		     ( SYMVALUE=.TEMP[1]<ADDRESSF>;
		       SYMVALUE<VEF>=1;
		       RETURN 1
		     );
		  END;
		RETURN 0
	END;

%3.1%	GLOBAL ROUTINE IDCHECKER(P,N)=
	BEGIN LOCAL L,TEMP;	%12-21-77%
	INCR I FROM 1 TO .N DO
	    BEGIN
	    L_@(@P-@I);
	    TEMP=(@P-@I);	%12-21-77%
            IF .L<LSF> THEN
		BEGIN
		CHECKEXTER(.L<LINKF>);
		IF NOT CHKULA(.L<LINKF>) THEN ERROR(.NSYM,#40);
	%THE FOLLOWING 1 LINE WERE ADDED ON 12-21-77 TO FIX BUG=#4 %
		IF UPLEVELCHECK(.L) THEN  .TEMP=.SYMVALUE;
		END;
	    END;
	END;
! ACTUAL SYNTAX ROUTINES FOLLOW
!-------------------------------


%V2H%	GLOBAL ROUTINE SLABEL=

%V2H%	  !WE HAVE ENCOUNTERED A LABEL FOLLOWED BY COLON; THE LABEL
%V2H%	  !LEXEME IS IN SYM, COLON LEXEME IN DEL.  READ ALL LABELS UNTIL
%V2H%	  !WE RUN OUT.  CHAIN ALL LABEL STES TOGETHER AND PUT CHAIN
%V2H%	  !INDEX INTO GLOBAL LABIND.

%V2H%	  BEGIN

%V2H%	    REGISTER STIND;	!TO HOLD INDEX OF LABEL STE

%V2H%	    DO
%V2H%	      BEGIN
%V2H%		IF .ST[STIND_.SYM<STEF>,1]<DEADALIVEF> NEQ 0
%V2H%		  THEN EXITCOMPOUND WARNEM(.NSYM,ERALUSEDLAB);
%V2H%		ST[.STIND,1]_.LABIND;	!STORE INDEX TO PREVIOUS LABEL
%V2H%		LABIND_.STIND;		!SAVE INDEX TO CHAIN OF LABELS
%V2H%	      END
%V2H%	      UNTIL (HRUND(); .DEL<LEFTHALF> NEQ HLABCOLON);	!UNTIL NO MORE LABELS

%V2H%	    IF .DEL<HCLASS> NEQ 0 %OPEN BRACKET%	!LABELS MUST PRECEDE OPEN BRACKET
%V2H%	      THEN (LABIND_0; WARNEM(.NDEL,ERCANTLABEL));
%V2H%	  END;



%V2H%	ROUTINE BIRTHLABEL(HIND)=

%V2H%	  !HIND - IS THE INDEX OF THE HEADER CELL OF THE EXPRESSION WHICH 
%V2H%	  !IS TO BE LABELLED BY THOSE LABELS IN THE CHAIN POINTED TO BY
%V2H%	  !GLOBAL LOCATION LABIND.

%V2H%	  !BIRTHLABEL STORES .HIND INTO THE PREVF OF THE ADDINFO WORD OF
%V2H%	  !ALL LABEL STES AND TURNS ON THE ALIVE BITS IN ALL STES TO
%V2H%	  !INDICATE THAT THERE ARE NO LABELS WHICH HAVE BEEN READ,
%V2H%	  !BUT NOT LINKED TO AN EXPRESSION.

%V2H%	  !BIRTHLABEL RETURNS THE INDEX TO THE STE CHAIN AS ITS VALUE.

%V2H%	  !ALL STES UPON ENTRY TO BIRTHLABEL MUST BE IN DORMANT
%V2H%	  !STATE:	DEADB=ALIVEB=0.
%V2H%	  !THEY WILL BE IN ALIVE STATE ON EXIT FROM BIRTHLABEL:	ALIVEB=1.

%V2H%	  BEGIN

%V2H%	    REGISTER	NEWSTUFF,	!WILL CONTAIN ALIVEM(ASK) + INDEX
%V2H%					!TO LABELLED EXPR TO BE ADDED TO
%V2H%					!ALL STES.
%V2H%			STIND;		!INDEX OF CURRENT STE.

%V2H%	    NEWSTUFF_ALIVEM+.HIND^15;	!HIND GOES IN PREVF
%V2H%	    STIND_.LABIND;		!GET INDEX TO FIRST STE.

%V2H%	    DO
%V2H%	      BEGIN
%V2H%		ST[.STIND,1]_.ST[.STIND,1]+.NEWSTUFF;	!UPDATE STE
%V2H%		STIND_.ST[.STIND,1]<NEXTF>;		!GET INDEX TO NEXT STE
%V2H%	      END
%V2H%	    UNTIL .STIND EQL 0;	!SIGNIFYING END OF THE CHAIN.

%V2H%	    STIND_.LABIND; LABIND_0;	!ZERO LABIND
%V2H%	    RETURN .STIND;		!AND RETURN THE INDEX TO THE CHAIN.
%V2H%	  END;



%V2H%	ROUTINE KILLLABEL(CHAIN)=

%V2H%	  !WE HAVE FINISHED COMPILING THE EXPRESSION WHICH WAS
%V2H%	  !LABELLED BY THE STES IN THE CHAIN POINTED TO BY CHAIN.
%V2H%	  !NOW WE WANT TO TURN ON ALL DEADBITS IN THE
%V2H%	  !CHAIN SO THAT LEAVE EXPRESSIONS WILL NOT BE ABLE TO REFERENCE
%V2H%	  !THE NOW DEFUNCT LABELS.  THIS ASSUMES ALL LABELS ARE IN
%V2H%	  !ALIVE STATE.  IT LEAVES ALL LABELS IN DEAD STATE.

%V2H%	  BEGIN

%V2H%	    REGISTER STIND;	!HOLDS CURRENT STE INDEX

%V2H%	    STIND_.CHAIN;		!GET INDEX TO FIRST STE

%V2H%	    DO
%V2H%	      BEGIN
%V2H%		ST[.STIND,1]<DEADALIVEF>_1;	!DEADB ON, ALIVEB OFF
%V2H%		STIND_.ST[.STIND,1]<NEXTF>;	!GET INDEX TO NEXT STE
%V2H%	      END
%V2H%	    UNTIL .STIND EQL 0;	!SIGNIFYING END OF THE CHAIN

%V2H%	  END;
%3.1%	GLOBAL ROUTINE EXPRESSION(TOG)=
	BEGIN LOCAL SAVDEC; EXTERNAL INDECS; 
	!
	! THIS ROUTINE, WHEN CALLED, WILL COMPILE THE CODE
	! FOR A SIMPLE EXPRESSION -- IT IS CALLED FROM A
	! VARIETY OF PLACES IN THE SYNTAX ANALYZER TO DO
	! JUST THAT. ON EXIT A CLOSE BRACKET OF SOME FORM
	! IS IN 'DEL', AND THE LEXEME FOR THE VALUE OF
	! THE EXPRESSION IS IN 'SYM'.
	! THE PARAMETER 'TOG' IS SIMPLY PASSED ON TO
	! 'GENCODE' TO CONTROL ACTUAL CODE GENERATION.
	!
	!
%V2H%	  IF .DEL<LEFTHALF> EQL HLABCOLON	!THEN WE HAVE ONE OR MORE LABELS.
%V2H%	    THEN SLABEL();			!GO PROCESS THEM
	SAVDEC_.INDECS; INDECS_0;
	WHILE .DEL<HCLASS> NEQ CLOBRAC DO
	    IF AEFOLLOWS()
		THEN HDELCLASS()
		ELSE IF .DEL<HCLASS> EQL DCLRTR
		    THEN RECOVER(.NDEL,21)
		    ELSE RECOVER(.NDEL,1);
%5.200.19%	IF .SYM<LSF> THEN FIXBADEXP();

	SYM_GENCODE(.SYM,.TOG);
	INDECS_.SAVDEC; REALS_0;
	END;
%3.1%	GLOBAL ROUTINE SCOMPOUND=

% PRINCIPLE:  READ UNTIL THE MATCHING CLOSING BRACKET(END OR ROCLO)
	1.READ ONCE SO THAT THE NEXT DELIMITER IS IN DEL.
	2.PROCESS THE DECLARATIONS.
	3.PROCESS THE EXPRESSIONS IN SUCCESSION.
	4.ACCEPT AN ARBITRARY EXPRESSION IN SUCCESSION.
	5.WHEN A SEMICOLON IS FOUND SKIP AND START ALL OVER AGAIN.
	6. IF THE CLOSING BRACKET IS FOLLOWED BY AN HEMPTY FUTSYM
	(IT SHOULD BE HEMPTY) PUT RESULT IN FUTSYM AND READ ONCE MORE%

%V2H%	BEGIN LOCAL BRAC,NOPEN, SEMCNT, NXTLOC, BLKP,CPPSAVER,SESSAVER,STPOVEC,OLDMAPTB,LFLAGS,LLABIND;
	 EXTERNAL MAXLOCAL,MAPTB,UNMAP,PTOVECTOR,INDECS,STRDEF,FLAGS,CODEPROP;
	BRAC_ .DEL<LEFTHALF>; SEMCNT_0;SESSAVER_.SESTOG; NOPEN_.NDEL;
	CPPSAVER_.CODEPROP; CODEPROP_0;
	INDECS_BLKP_.FUTDEL<HCLASS> EQL DCLRTR;LFLAGS_.FLAGS;
        IF .CODETOG  THEN GCE0(.BLKP);
        IF .BLKP THEN 
	    BEGIN
%V2H%	    SETLABSIFNECESSARY(BEC);
	    BLOCKLEVEL_ .BLOCKLEVEL + 1;
	    STPOVEC_.PTOVECTOR; OLDMAPTB_.MAPTB;
	    MAPTB_0; STRDEF_.STRDEF AND -2;
%V2H%	    END
%V2H%	    ELSE SETLABSIFNECESSARY(CMPEXC);
        NXTLOC_ .NEXTLOCAL;
	WHILE .FUTDEL<HCLASS> EQL DCLRTR DO 
	    BEGIN
            HRUND();
	    IF .SYM NEQ HEMPTY THEN WARNEM(.NSYM,#105);
            (@DEL)(); IF .DEL<LEFTHALF> NEQ HSEMCOL 
                THEN DEMAND(.NDEL,#100,1);
	    END;
        INDECS_0;
	IF .REALFS NEQ 0 THEN IDFIXFS();
	HRUND();

	BEGIN

	UNTIL .DEL<LEFTHALF> EQL .BRAC+#375240 DO
	    BEGIN
		SESTOG_0;
		EXPRESSION(2*( .SEMCNT GTR 0 ));
		SESSAVER_.SESSAVER OR .SESTOG;
		IF .SYM EQL HEMPTY THEN SYM_ZERO;
		IF .DEL<LEFTHALF> EQL HSEMCOL 
		  THEN
		    BEGIN
		    IF .CODETOG THEN
		    BEGIN
		    IF (SEMCNT_.SEMCNT+1) EQL 1
			 THEN ( SYM_GENCODE(.SYM,2));
		    GCE1(.SYM);
		    FIXSIDEEFFECTS();
		    END;
		    HRUND();
		    END
		  ELSE IF .DEL<LEFTHALF> NEQ .BRAC+#375240

	!ALLOW ELSE TO CLOSE THE COMPOUND EXPRESSION OR BLOCK AFTER
	!WE OUTPUT A PAIR OF FATAL ERROR MESSAGES.  #30 POINTS
	!ROUGHLY TO THE OPEN DELIMITER AND ERNOCBDEL POINTS ROUGHLY
	!TO THE ELSE.
	!ON RECOVERY, ACT AS IF THE PROPER CLOSE BRACKET APPEARED
	!BEFORE THE ELSE AND GO ON.

	THEN

	BEGIN
		IF .DEL<LEFTHALF> EQL HELSE
		  THEN
		    BEGIN
		      ERROR(.NOPEN,#30);
	              ERROR(.NDEL,ERNOCBDEL);
		      ERRLEVEL_0;
		      EXITCOMPOUND[4]
		    END
	  ELSE
			(ERROR(.NOPEN,24);DEMAND(.NDEL,25,.BRAC EQL HBEGIN))
	END;
		ERRLEVEL_0;
	    END;
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .CODETOG THEN IF (.SEMCNT GEQ 1 OR .BLKP  OR .CODEPROP) 
    	   THEN SYM_GCE2(GENCODE(.SYM,2),( IF .BLKP THEN   
	     IF .FUTDEL<LEFTHALF> EQL HELUDOM THEN  %6-2-77%
        (.NXTLOC-(IF .NEXTLOCAL GTR .MAXLOCAL THEN .NEXTLOCAL ELSE .MAXLOCAL) -1)
                 ELSE -1  ELSE 0))
	   ELSE GCE2(ZERO,0);  !5-26-77
	IF CORRECTP1() THEN FUTSYM_.SYM
	ELSE(IF FUTAE() THEN RECOVER(.NFUTDEL,3) ELSE RECOVER(.NFUTSYM,12); ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND();

	END;

	SESTOG_.SESTOG OR .SESSAVER; CODEPROP_.CODEPROP OR .CPPSAVER;
        IF .BLKP THEN 
	  BEGIN
	  UNMAP(); MAPTB_.OLDMAPTB; FLAGS<18,16>_.LFLAGS<LEFTHALF>;
	  IF .NEXTLOCAL GTR .MAXLOCAL THEN MAXLOCAL_.NEXTLOCAL;
	  BLOCKLEVEL_.BLOCKLEVEL-1; BLOCKPURGE(.BLOCKLEVEL);
	  PTOVECTOR_.STPOVEC;
	  NEXTLOCAL_.NXTLOC;
	  END;
%V2H%	KILLLABSIFNECESSARY;

END;
%3.1%	GLOBAL ROUTINE SSET(TYPE)=

%PRINCIPLE:READ UNTIL THE CLOSING BRACKET "TES"
	1.READ SO THAT THE NEXT DELIMITER IS IN DEL(THE CASE EXPR USES THIS ROUTINE TOO)
	2.PROCESS THE INNER EXPRESSION IN SUCCESSION.
	3.SKIP A SEMICOLON AND START ALL OVER AGAIN.
	4.ACCEPT AN ARBITRARY EXPRESSION.
	5.IF FUTSYM FOLLOWING TES IS HEMPTY(AS IT SHOULD BE),TRANSMIT
	THE RESULT TO FUTSYM AND READ ONCE MORE IN ORDER TO DELETE TES%

BEGIN LOCAL CASETYPE; CASETYPE_(.DEL<LEFTHALF> EQL HOF);
	IF .TYPE THEN CLEARRTGT();
	IF .CASETYPE THEN HRUND() ELSE (IF .CODETOG THEN GCE0(0););HRUND();
	UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HSEMCOL DO
	    BEGIN
		EXPRESSION(0); VTARGET_2; SYM_GENCODE(.SYM,2);
		IF .SYM EQL HEMPTY THEN SYM_ZERO;
		IF .DEL<LEFTHALF> EQL HSEMCOL 
		    THEN BEGIN
			IF .CODETOG THEN
			IF NOT.CASETYPE THEN SYM_GCE1(.SYM) ELSE
			IF .TYPE 
			    THEN (SYM_GCOST3(.SYM);CLEARSOME();GTPURGE(1))
			    ELSE (SYM_GCOST3(.SYM);GTPURGE(1);RESRT(0));
			HRUND()
			END;
		ERRLEVEL_0;
	    END;
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .DEL<LEFTHALF> EQL HTES
		THEN 
			BEGIN
			IF .CODETOG THEN
			IF NOT.CASETYPE THEN SYM_GCE2(.SYM,0) ELSE
			IF .TYPE 
			    THEN (SYM_GCOST4(.SYM); CLEARSOME(); GTPURGE(1))
			    ELSE (SYM_GCOST4(.SYM); RESRT(1); CLEARSOME();
				  GTPURGE(2); LIVR(.SYM); GTDECR());
			END
           	ELSE (RECOVER(.NDEL,2);RETURN ERRLEVEL_1);
	IF .FUTSYM EQL HEMPTY AND .FUTDEL<HCLASS> EQL CLOBRAC
		THEN FUTSYM_.SYM
	ELSE (IF FUTAE() THEN RECOVER(.NFUTDEL,3) ELSE RECOVER(.NFUTSYM,12); ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND()
END;
ROUTINE SOPERATOR=

	%OPERATOR IN QUESTION IS IN DEL;
	1. STORE LEFTOPERAND AND OPERATOR;
	2.TEST IF LEFT OPERAND IS LEGAL;
	3.READ SO THAT NEXTDEL IS IN DEL.
	4.IF DEL GOES FIRST THEN (CALL ROUTINE FOR DEL,RETURN TO 4)
	5.CHECK IF RIGHT OPERAND IS LEGAL.
	6.COMPUTE RESULT.%

IF .DEL<LEFTHALF> NEQ HSTO
    THEN BEGIN LOCAL LEFTOP, OP;
%5.200.19%	IF .SYM<LSF> THEN FIXBADEXP();
	LEFTOP_.SYM; OP_.DEL;

	IF (.SYM EQL HEMPTY) XOR .OP<HUNARY>
	    THEN(RECOVER(.NDEL,6);RETURN(ERRLEVEL_1));
	HRUND();
%V2H%	  !CHECK TO SEE IF WE HAVE A LABELLED EXPRESSION.  IF SO,
%V2H%	  !GET RID OF ALL LABELS BEFORE CHECKING PRIORITY OF NEXT DELIMITER.
%V2H%	  IF .DEL<LEFTHALF> EQL HLABCOLON THEN SLABEL();
	WHILE .DEL<HPRIORITY> LSS .OP<HPRIORITY> 
         OR(.DEL<HPRIORITY> EQL .OP<HPRIORITY> AND .OP<HUNARY>) DO
    	BEGIN
	     IF SEFOLLOWS()
	       THEN HDELCLASS()
	       ELSE (IF .DEL<HCLASS> EQL OPENBRACKET
		THEN RECOVER(.NDEL,7) ELSE RECOVER(.NDEL,4); ERRLEVEL_1);
	     IF .ERRLEVEL THEN RETURN
        END;
	IF SUCCESSIVERELATIONALS(.OP) THEN WARNEM(.NDEL,5);
%5.200.19%	IF .SYM<LSF> THEN FIXBADEXP();
	IF (.SYM EQL HEMPTY AND (NOT(  SEFOLLOWS())))
	      THEN (RECOVER(.NFUTDEL,4); ERRLEVEL_1)
	      ELSE SYM_IF .OP<HUNARY>
					THEN GENGRAPH(.SYM,.OP,1)
					ELSE GENGRAPH(.LEFTOP,.SYM,.OP,2);
	END

    ELSE %HERE FOLLOWS THE STORE OPERATOR%

	BEGIN LOCAL L,LEFTPARTLIST[8],OP; L_-1;OP_.DEL;
	WHILE .OP<HPRIORITY> GEQ .DEL<HPRIORITY> DO
	BEGIN IF .SYM EQL HEMPTY AND
		 (NOT (.DEL<HUNARY> OR .DEL<HCLASS> EQL OPENBRACKET))
        THEN (RECOVER (.NDEL,8); ERRLEVEL_1)
	ELSE IF .OP<HPRIORITY> GTR .DEL<HPRIORITY>
		THEN
%5.200.19%		(IF .SYM<LSF> THEN FIXBADEXP();
%5.200.8%		IF AEFOLLOWS() THEN HDELCLASS()
%5.200.8%				ELSE IF .DEL<HCLASS> EQL DCLRTR THEN RECOVER(.NDEL,21)
%5.200.8%								ELSE RECOVER(.NDEL,1))

		ELSE BEGIN
%5.200.19%	IF .SYM<LSF> THEN FIXBADEXP();
		L_.L+1;    %ANOTHER _ HAS BEEN FOUND%
			IF .L EQL 8 THEN ERROR(.NSYM,9)
				ELSE LEFTPARTLIST[.L]_.SYM;
%V2H%			HRUND();
%V2H%			IF .DEL<LEFTHALF> EQL HLABCOLON THEN SLABEL();
		     END;
	IF .ERRLEVEL THEN RETURN
	END;		% NOW IS L=# OF LEFTARROWS%
	IF NOT AEFOLLOWS() AND .SYM EQL HEMPTY THEN (RECOVER(.NFUTDEL,10);ERRLEVEL_1)
	ELSE %THE LEFTPARTS HAVE BEEN COMPUTED SO THAT THERE IS NO HARM
	IN  ASSIGNING  FROM RIGHT TO LEFT%
	WHILE .L GEQ 0 DO
		BEGIN
		SYM_GENGRAPH(@(LEFTPARTLIST[.L]),.SYM,.OP,2);
		L_.L-1;
		END
 END;
ROUTINE SUSERCALL(CREAT)=

% CREAT IS 1 FOR COROUTINE CREATION, 0 FOR CALL.
PRINCIPLE: READ UNTIL THE RIGHT PARENTHESIS
	1.SAVE THE NAME AND INITIATE THE NUMBER OF PARAMETERS.
	2.READ IN ORDER TO GET THE FIRST PARAMETER'S,BEGIN IN SYM AND DEL.
	3.TREAT THE PARAMETERS SUCCESSIVELY.
	4.WHEN A COMMA IS FOUND STSRT WITH NEXT PARAMETER.
	5.IF FUTSYM FOLLOWING THE RIGHT PARENTHESIS  IS HEMPTY 
	(AS IT SHOULD BE) TRANSMIT SYM TO FUTSYM AND READ ONCE MORE.%

BEGIN LOCAL FU,M;   %4-12-77%
        IF .REALS NEQ 0
          THEN (CHECKEXTER(.REALS);
               IF NOT CHKULA(.REALS) THEN ERROR(.NSYM,#40));
        FU_SYM_GENCODE(.SYM,1); M_1;
	% M IS INITIATED WITH 1 TO COUNT THE LAST PARAMETER%
        IF .CREAT THEN
          IF .DEL<LEFTHALF> NEQ HPAROPEN THEN
            (RECOVER(.NDEL,#72);   RETURN  ERRLEVEL _ 1);
        HRUND();
	UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HCOMMA DO
             BEGIN
		EXPRESSION(2);
		 IF .DEL<LEFTHALF> EQL HCOMMA
     		    THEN BEGIN M_.M+1; IF .SYM EQL HEMPTY THEN ERROR(.NSYM,11);
     			IF .CODETOG THEN (IF .CREAT THEN GCREA1(.SYM)
                                          ELSE GFRC1(.SYM));  
                        HRUND();
			FIXSIDEEFFECTS();
          		END;
		ERRLEVEL_0
	     END;	%NOW IS M = 1+# OF COMMAS%
	IF .SYM EQL HEMPTY
	    THEN IF .M EQL 1 THEN M_0 ELSE ERROR(.NSYM,11);
	IF .DEL<LEFTHALF> EQL HROCLO
             THEN (IF .SYM<LEFTHALF> EQL GTLEX THEN EXPRESSION(2);  %4-14-77 %
	           SYM _ IF .CODETOG THEN
                             (IF .CREAT THEN GCREA2(.SYM,.FU,.M)
                              ELSE GFRC2(.SYM,.FU,.M))  
                         ELSE ZERO)
	     ELSE (RECOVER(.NDEL,2);RETURN ERRLEVEL_1);
	FIXSIDEEFFECTS();
	IF CORRECTP1() THEN FUTSYM_.SYM
   	     ELSE (RECOVER(.NFUTSYM,IF FUTAE() THEN 3 ELSE 12);ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND();
        .M
END;
%3.1%	GLOBAL ROUTINE SCREATE =
%_CALLS SUSERCALL TO DO THE FUNCTION-CALL LIKE PART.
  OTHERWISE STRAIGHTFORWARD.
_%
BEGIN
  LOCAL NPAR,SAVVAL;
  HRUND();                         ! READ PAST 'CREATE'.
  GCREA0();
  CLEARRTGT();
  NPAR _ SUSERCALL(1);
  SAVVAL _ .SYM;

  IF .DEL<LEFTHALF> NEQ HCRAT THEN
    (RECOVER(.NDEL,#67);   RETURN ERRLEVEL _ 1);
  HRUND();                         ! READ PAST 'AT'.

  CLEARRTGT();
  EXPRESSION(2);
  IF .SYM EQL HEMPTY OR .DEL<LEFTHALF> NEQ HLENGTH THEN
    ( RECOVER(.NDEL,#70);   RETURN ERRLEVEL _ 1)
  ELSE
  IF .CODETOG THEN GCREA3(.SYM);
  HRUND();                         ! READ PAST 'LENGTH'.

  EXPRESSION(2);
  IF .SYM EQL HEMPTY OR .DEL<LEFTHALF> NEQ HTHEN THEN
    ( RECOVER(.NDEL,#71);   RETURN ERRLEVEL _ 1)
  ELSE
    IF .CODETOG THEN GCREA4(.SYM);
  HRUND();                         ! READ PAST 'THEN'.

  CLEARRTGT();
  EXPRESSION(2);
  IF .SYM EQL HEMPTY THEN SYM _ ZERO;
  IF .CODETOG THEN GCREA5(.SYM);
  CLEARRTGT();
  LIVR(SYM _ .SAVVAL)
END;    ! END OF SCREATE.
%3.1%	GLOBAL ROUTINE SEXCHJ =
%_STRAIGHTFORWARD ANALYSIS OF EXCHJ.
  EMPTY VALUE-EXPRESSION ALLOWED, WITH OR WITHOUT COMMA.
  THE CODE FOR THE PROCESS-EXPRESSION IS NOT GENERATED UNTIL IT
  CAN BE DETERMINED IF IT CAN BE OBTAINED WITH A SINGLE MOVE, AND AFTER
  THE VALUE-EXPRESSION.  TO DO THIS, INSPECT VALUES OF CODEPROP.
_%
BEGIN
  LOCAL SAVECP,PPCP;

        ! WINDOW:  XXX  EXCHJ  0  (

  IF (.FUTSYM NEQ HEMPTY) OR (.FUTDEL<LEFTHALF> NEQ HROPEN) THEN
    ( HRUND();   RECOVER(.NFUTDEL,#64);  RETURN ERRLEVEL _ 1)
  ELSE (HRUND();  HRUND());            ! READ PAST '('.

  CODEPROP _ 0;            ! TO SEE IF PROC IS ONE-MOVER.
  EXPRESSION(2);                       ! COMPILE PROCESS EXPRESSION.
  PPCP _ .CODEPROP;

  IF .SYM EQL HEMPTY THEN
    ( RECOVER(.NSYM,#65);  RETURN ERRLEVEL _ 1)
  ELSE IF .CODETOG THEN SAVECP _ GEXCH0(.SYM);

  CODEPROP _ 0;
  SYM _ HEMPTY;                         ! PREPARE FOR TEST BELOW.
  CLEARRTGT();

  IF .DEL<LEFTHALF> EQL HCOMMA THEN
     ( HRUND();  EXPRESSION(2));       ! COMPILE VALUE-EXPRESSION.
  IF .DEL<LEFTHALF> NEQ HROCLO THEN
    ( RECOVER(.NDEL,#66);  RETURN ERRLEVEL _ 1)
  ELSE
    IF .SYM EQL HEMPTY THEN SYM _ ZERO;
  IF CORRECTP1() THEN
    ( IF .CODETOG THEN
        FUTSYM _ GEXCH1(.SYM,(IF NOT (.PPCP OR .CODEPROP) THEN .SAVECP ELSE 0)))
  ELSE
    ( RECOVER(.NDEL,IF FUTAE() THEN 3 ELSE 12);  RETURN ERRLEVEL _ 1);
  HRUND();                             ! READ PAST ')'.
  CLEARRTGT();
  CODEPROP _ 1
END;   ! END OF SEXCHJ.
%3.1%	GLOBAL ROUTINE SSQOPEN=

%PRINCIPLE:READ UNTIL SQUCLOSE AND COLLECT THE SUBSCRIPTS
	1.DISTINQUISH BETWEEN THE SIMPLE AND NON-SIMPLE STRUCTURE
	(AS DESCRIBED BY BILL); THE NON-SIMPLE A[I,J,0] WITH MAP STRUCTURE
	:A IS TREATED AS STRUC(A,I,J) AND THE SYNTAX CODE FOR IT IS THE 
	SAME AS FOR SPAROPEN.
	THE SIMPLE A[I,.....,J,0] IS TREATED AS FOLLOWS.
	2.SAVE STRUCTURE NAME AND READ ONCE TO GET THE BEGINNING OF THE 
	FIRST SUBSCRIPT
	3.WHENEVER A COMMA IS FOUND ,BOOK SUBSCRIPT AND DELETE COMMA
	4.IF FUTSYM IS 0 FOLLOWING SQUCLO(AS IT SHOULD BE)
	TRANSMIT SYM TO FUTSYM AND READ ONCE MORE.RESULT IS P1.%

BEGIN 
  LOCAL ACTUALS,  ! STE INDEX OF ACTUAL PARAMETER BLOCK
          INCACTS,  !  "   "    "  INCARNATION ACTUALS BLOCK
          CPTOSYM,  ! CHARACTER POINTER TO SYM IN CASE OF EXPANSION ERRORS
          NUMPARMS, ! NUMBER OF PARAMETERS ALLOWED
          STRUCT,   ! STE INDEX OF STRUCTURE
          SAVELAST, ! LAST PARAMETER WHEN EXTRAS PASSED
          DEFAULT,  ! DEFAULT VECTOR STRUCTURE USED
          SIMPLE;   ! TRADITIONAL MISNOMER FOR MACRO-TYPE EXPANSION.
    REGISTER T; LOCAL PSZ;
    LOCAL L;
    MAP STVEC ACTUALS:INCACTS:REALS:STRUCT;
    MACRO DEFAULT0=IF .SYM EQL HEMPTY THEN SYM_ZERO$;

    % IF WE DO NOT HAVE A SYMBOL IN SYM, OR THE SYMBOL HAS NOT
      BEEN MAPPED, WE DEFAULT THE VECTOR STRUCTURE WITH ACTUAL OF 1%

    IF DEFAULT_
      (IF .REALS EQL 0
         THEN 1
         ELSE
          (CHECKEXTER(.REALS);
           IF MAPPABLE((.REALS[0]<TYPEF>))
             THEN (INCACTS_.REALS[1]<STRF>) EQL 0
             ELSE 1))
      THEN INCACTS_MKDUMINCA(.PTOVECTOR);
    STRUCT_.INCACTS[0]<STRXF>;
    NUMPARMS_.STRUCT[1]<NPARMF>; %USED TO CALCULATE DISPLACEMENT IN PARS.%
    DEFAULT0;
    
    ACTUALS_GETSPACE(PSZ_.INCACTS[0]<PSZF>);
    IF SIMPLE_.STRUCT[1]<SIMBITAF>
      THEN CPTOSYM_.NSYM
      ELSE INCR I FROM 1 TO .NUMPARMS DO
             IF .CODETOG THEN GFRC1(.INCACTS[.I]);

    BEGIN
      LOCAL NOMORE;
      MACRO CLOSEBR=
              (IF .DEL<LEFTHALF> EQL HSQCLO AND
                .FUTDEL<LEFTHALF> EQL HSTO THEN STUTYPE_1;
              IF .DEL<LEFTHALF> EQL HCOMMA
                AND .FUTSYM EQL HEMPTY
                AND .FUTDEL<LEFTHALF> EQL HSQCLO
                 THEN (HRUND(); 1)
                 ELSE .DEL<LEFTHALF> EQL HSQCLO)$,

            MOREACTS=
              (IF NOMORE_CLOSEBR
                 THEN .NUMPARMS GTR .L
                 ELSE
                   (IF .DEL<LEFTHALF> NEQ HCOMMA
                      THEN (RECOVER(.NDEL,2);
                            RETURN ERRLEVEL_1);
                    HRUND();
                    EXPRESSION(0);
                    DEFAULT0;
                    1))$,

            ACT=IF .NOMORE THEN ZERO ELSE .SYM$;

      DEL<LEFTHALF>_HCOMMA;
      L_-1;
      NOMORE_0;
  
      DO IF (L_.L+1) LEQ .NUMPARMS
           THEN ACTUALS[.L]_ACT
           ELSE WARNEM(.NSYM,ERSMEXACT)
        WHILE MOREACTS;
  
	!V2G- IF NOT USING THE DEFAULT STRUCTURE WARN IF LESS THAN THE SPECIFIED
	!V2G- NUMBER OF ACTUALS IS PASSED.
	IF .L LSS .NUMPARMS THEN IF NOT .DEFAULT THEN WARNEM(.NSYM,ERFEWERACT);	!V2G-

      IF .SIMPLE
        THEN GSSA(.ACTUALS,.INCACTS,.STRUCT,1,.CPTOSYM)
        ELSE
          BEGIN
            IF NOT .CODETOG THEN EXITBLOCK;
            INCR I FROM 0 TO .NUMPARMS-1 DO
              GFRC1(SYM_GENCODE(.ACTUALS[.I],2));
            SYM_GFRC2(SYM_GENCODE(.ACTUALS[.NUMPARMS],2), .STRUCT+LSM,
                      .NUMPARMS^1+1)
          END;
    END;
	IF CORRECTP1() THEN FUTSYM_.SYM
	     ELSE (RECOVER(.NDEL,IF FUTAE() THEN 3 ELSE 12);ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND();
        IF .DEFAULT THEN RELEASESPACE(.INCACTS,.PSZ);
        RELEASESPACE(.ACTUALS, .PSZ);
END;
%3.1%	GLOBAL ROUTINE SPTR=

	%PRINCIPLE: READ UNTIL THE MATCHING POINTER CLOSE
	1. INITIATE THE  POINTER PARAMETERS WITH THEIR DEFAULT
	VALUES AND SAVE NAME.
	2. READ ONCE TO START WITH THE FIRST POINTER PARAMETER
	3.READ THE PARAMETERS SUCCESSIVELY,IF A PARAMETER IS HEMPTY
	THEN GO ON TO THE NEXT ONE, THE DEFAULT VALUE HAS ALREADY 
	BEEN SET.
	4.THE FINISHING PART IS EXACTLY LIKE THAT OF THESUSERCALL
	OR SQUOPEN %

BEGIN LOCAL NAME, PAR[4], L; NAME_.SYM; PAR[1]_36;
	PAR_L_PAR[2]_PAR[3]_0;
	HRUND();
	UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HCOMMA DO
	    BEGIN
		EXPRESSION(0);
		IF .DEL<LEFTHALF> EQL HCOMMA
			THEN    BEGIN
				 IF .SYM NEQ HEMPTY THEN PAR[.L]_.SYM;
				L_.L+1; HRUND()
	          		END;
		IF .L GTR 4 THEN (ERROR(.NSYM,#41); L_4);
		ERRLEVEL_0
	    END;
        PAR[.L] _ .SYM;
	IF .DEL<LEFTHALF> EQL HPOINTCLO
          	THEN (IF .CODETOG THEN SYM_GENGRAPH(.NAME,.PAR,.PAR[1],
				.PAR[2],.PAR[3],HPTOPEN^18+(NGPTR<0,0> AND #777777),5)
%5.200.2%				ELSE SYM_.NAME)
          	ELSE (RECOVER(.NDEL,2);RETURN ERRLEVEL_1);
	IF CORRECTP1() THEN FUTSYM_.SYM
          	ELSE (RECOVER (.NFUTDEL,IF FUTAE() THEN 3 ELSE 12); ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND()
END;
%3.1%	GLOBAL ROUTINE SCASE=

	%THE ROUTINE CONSISTS OF TWO PARTS,THE "SIMPLE CASE" AND THE
	"GENERAL CASE".   A SIMPLE CASE HAS THE FORM 
	CASE<CONSTANT> OF SET E0;E1;.....EN TES
	AND IF CONSTANT =I THEN IT IS COMPILED AS(EI),I.E.
	ALL THE OTHER EXPRESSION ARE SIMPLY SKIPPED%

  BEGIN
    ROUTINE CONSTCASE=
        BEGIN LOCAL VAL,EN,SVTARGET; EN_LITV(.SYM);VAL_0;
	!!! THE FOLLOWING 4 STATEMENTS UNDO THE CASE SKELETON
	ACPR2();	! --> C1
	ERASEBOT(.CODEPTR);
	CODEPTR_.CT[.CODEPTR,0]<PREVF>;	! --> C0
	UNTEMPLATE();
	IF .FUTDEL<LEFTHALF> NEQ HSET OR .FUTSYM NEQ HEMPTY
          	THEN (RECOVER(.NFUTSYM,16);RETURN ERRLEVEL_1);
	HRUND(); SHUTOFFCODE(); ! WINDOW: (0,"SET", EX1S, EX1D)
        SVTARGET=.VTARGET;
        UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HSEMCOL DO
	    BEGIN
		IF .EN EQL 0 AND .CODETOG NEQ 0 THEN (TURNONCODE(); GCE0(0);VTARGET=0);
                HRUND(); ! WINDOW: (EX1S, EX1D, EX1FS, EX1FD)
		EXPRESSION(0); 				! WINDOW: (EXPR, (";"/"TES"),...)
		IF .DEL<LEFTHALF> EQL HSEMCOL THEN
			 BEGIN IF .EN EQL 0 AND .CODETOG 
            		THEN (IF .SYM EQL HEMPTY THEN SYM_ZERO; VAL_GCE2(.SYM,0);SHUTOFFCODE(););
            		EN_.EN-1;
          		END
		ELSE IF .CODETOG NEQ 0 AND .EN EQL 0 THEN SHUTOFFCODE();
		ERRLEVEL_0

	    END;
	TURNONCODE();
	IF .SYM EQL HEMPTY OR .EN GTR 0 THEN SYM_ZERO;
	IF .DEL<LEFTHALF> EQL HTES
          	THEN(IF .CODETOG AND .EN EQL 0 THEN VAL_GCE2(.SYM,0))
          	ELSE(RECOVER(.NDEL,2);RETURN ERRLEVEL_1);
	IF .FUTSYM EQL HEMPTY AND .FUTDEL<HCLASS> EQL CLOBRAC
          	THEN FUTSYM_.VAL ELSE (IF FUTAE() THEN RECOVER(.NFUTDEL,3)  
                ELSE RECOVER(.NFUTSYM,12);ERRLEVEL_1);
	IF .ERRLEVEL EQL 0 THEN HRUND();
        VTARGET=.SVTARGET
        END;


	% PRINCIPLE: READ IN FIRST LOOP TILL OF AND IN
	SECOND         SET EXPR.
	1.INITIATE THE NUMBER OF CASE EXPRESSION AT ZERO
	2.READ ONCE IN ORDER TO START THE ANALYSIS OF THE FIRST
	CASE EXPRESSION.
	3. WHEN COMMA IS FOUND INCREASE N AND START WITH NEXT 
	CASE EXPRESSION
	4.WHEN OF IS FOUND TEST IF IT IS FOLLOWED BY SET
	5. ANALYSE THE SET EXPRESSION SIMILAR AS IN ROUTINE SSET%

%V2H%	BEGIN LOCAL LLABIND, N;  N_1; IF .CODETOG THEN GCOST0(); SETLABSIFNECESSARY(COSTC); HRUND();
        DO
		BEGIN 
		EXPRESSION(0); VTARGET_-1; SYM_GENCODE(.SYM,2);
		IF .DEL<LEFTHALF> EQL HCOMMA
			THEN BEGIN N_.N+1;IF .SYM EQL HEMPTY THEN ERROR(.NDEL,15);
			     IF .CODETOG THEN  GCOST1(.SYM);
			     HRUND();
			     FIXSIDEEFFECTS();
		   	     END;
		ERRLEVEL_0
		END		%N=1+ # OF COMMAS%
	UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HCOMMA;
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .DEL<LEFTHALF> EQL HOF
%V2H%	    THEN (IF .CODETOG THEN(IF LITP(.SYM) AND .N EQL 1 THEN RETURN (CONSTCASE(); KILLLABSIFNECESSARY) ELSE
			GCOST2(.SYM,.N);
		    IF .N EQL 1 THEN (GTPURGE(0);GTINCR();SAVRT(0))))
%V2H%	    ELSE (RECOVER(.NDEL,2);RETURN (ERRLEVEL_1; KILLLABSIFNECESSARY));
	FIXSIDEEFFECTS();
	IF .FUTDEL<LEFTHALF> NEQ HSET OR .FUTSYM NEQ HEMPTY
	    THEN (RECOVER(.NFUTDEL,16);ERRLEVEL_1);
%V2H%	SSET(.N GTR 1);
%V2H%	KILLLABSIFNECESSARY;
    END
END;
%3.1%	GLOBAL ROUTINE SREP=
    BEGIN LOCAL LLABIND, J, DEC;
    !
    !        THIS ROUTINE COMPILES THE CODE FOR INCR/DECR LOOPS.
    !
    ROUTINE IDDEL=
	BEGIN LOCAL X;
	IF (X_.DEL<LEFTHALF> ) EQL HFROM THEN 1 ELSE
	IF .X EQL HTO THEN 2 ELSE
	IF .X EQL HBY THEN 3 ELSE
	IF .X EQL HDO THEN 4 ELSE 0
	END;
    DEC_.DEL<LEFTHALF>; HRUND();
    SYM_DECLTEMPREG(.SYM,1);
    IF .CODETOG THEN GID0(.SYM);
%V2H%	SETLABSIFNECESSARY(IDFTDC);
    INCR I FROM 1 TO 4 DO
	BEGIN
	IF (J_IDDEL()) LSS .I
%V2H%	    THEN (RECOVER(.NDEL,36); RETURN (ERRLEVEL_1; KILLLABSIFNECESSARY))
	    ELSE IF .J GTR .I THEN
		INCR K FROM .I TO .J-1 DO
		    IF .CODETOG THEN
			CASE .K OF
			   SET
			    0;
			    GID1(ZERO);
			    GID2(LITLEXEME(IF .DEC EQL HDECR THEN (1^35) ELSE NOT(1^35)));
			    (GID3(LITLEXEME(1),.DEC EQL HDECR);CLEARRTGT());
%V2H%			    (RECOVER(.NDEL,37); RETURN(ERRLEVEL_1; KILLLABSIFNECESSARY));
			    TES;
	HRUND();  EXPRESSION(0); VTARGET_IF .I NEQ 4 THEN -1 ELSE 0; SYM_GENCODE(.SYM,1);
	I_.J;
	IF .SYM EQL HEMPTY THEN ERROR(.NSYM,40);
	IF .CODETOG THEN
	    CASE .I OF
		SET
		0;
		SYM_GID1(.SYM);
		SYM_GID2(.SYM);
		(SYM_GID3(.SYM,.DEC EQL HDECR);CLEARRTGT());
		SYM_GID4(.SYM,.DEC EQL HDECR);
		TES;
	FIXSIDEEFFECTS();
	END;
	DECLTEMPREG(0,0);  CLEARRTGT();
%V2H%	KILLLABSIFNECESSARY;
    END;
%V2H%	GLOBAL ROUTINE SLEAVE=

%V2H%	  !ENTER WITH WINDOW:	XXX	LEAVE	XXX	XXX
%V2H%	  !			SYM	DEL	FUTSYM	FUTDEL
%V2H%	  !
%V2H%	  !FUTSYM MUST BE DECLARED A LABELT SYMBOL AND MUST BE IN ALIVE
%V2H%	  !STATE:	ALIVEB=1.

%V2H%	  BEGIN
%V2H%	    REGISTER HIND;	!TO HOLD INDEX OF LABELLED HEADER

%V2H%	  BEGIN
%V2H%	    !FIRST MAKE SURE THAT .FUTSYM IS A PROPER LABEL.
%V2H%	    IF .ST[HIND_.FUTSYM<STEF>,0]<TYPEF> NEQ LABELT
%V2H%	      THEN EXITCOMP (ERROR(.NFUTSYM,ERIMPLABEL); ERRLEVEL_1);
%V2H%	    IF NOT .ST[.HIND,1]<ALIVEB> THEN EXITCOMP( ERROR(.NFUTSYM,EROUTLABSCOPE); ERRLEVEL_1);

%V2H%	    !NOW GET THE INDEX TO THE LABELLED HEADER
%V2H%	    HIND_.ST[.FUTSYM<STEF>,1]<PREVF>;
%V2H%	  END;

%V2H%	    !NOW MOVE WINDOW TO CHECK FOR "WITH" EXPRESSION
%V2H%	    HRUND();		!GET NEXT DEL INTO DEL
%V2H%	    IF .DEL<LEFTHALF> EQL HWITH
%V2H%	      THEN (HRUND(); EXPRESSION(0))
%V2H%	      ELSE SYM_ZERO;

%V2H%	    !NOW GET AND CHECK THE RESULT EXPRESSION
%V2H%	    VTARGET_2; SYM_GENCODE(.SYM,2); IF .ERRLEVEL THEN RETURN;
%V2H%	    IF .SYM EQL HEMPTY THEN SYM_ZERO;
%V2H%	    IF .CODETOG THEN (SYM_ GLEAVE(.SYM,.HIND));

%V2H%	  END;
%3.1%	GLOBAL ROUTINE SESCAPE=
    BEGIN
    !
    !    THIS ROUTINE HANDLES COMPILATION OF ALL ESCAPE EXPRESSIONS.
    !
    LOCAL ESC, D;
    ESC_ IF (D_.DEL<LEFTHALF>) EQL HRETURN THEN 0 ELSE
		IF .D EQL HEXIT THEN 1 ELSE
		IF .D EQL HEXITLOOP THEN 2 ELSE
		IF .D EQL HEXITBLOCK THEN 3 ELSE
		IF .D EQL HEXITCOMP THEN 4 ELSE
		IF .D EQL HEXITCOND THEN 5 ELSE
		IF .D EQL HEXITSELECT THEN 6 ELSE
		IF .D EQL HEXITCASE THEN 7 ELSE
		IF .D EQL HEXITSET THEN 8 ELSE  -1;
    HRUND();
    D_LITLEXEME(1);
    IF .DEL<LEFTHALF> EQL HSQOPEN AND .SYM EQL HEMPTY THEN
	    BEGIN HRUND(); EXPRESSION(2);
	    IF NOT LITP(D_.SYM) OR .D EQL HEMPTY THEN ERROR(.NSYM,41);
	    IF .DEL<LEFTHALF> NEQ HSQCLO THEN
		(RECOVER(.NDEL,42); RETURN ERRLEVEL_1);
	    FIXFUTDEL(); ! KLUDGE TO HANDLE UNARY OP AFTER ].
	    HRUND();
	    END;
    EXPRESSION(0); VTARGET_2; SYM_GENCODE(.SYM,2);
    IF .ERRLEVEL THEN RETURN;
    IF .SYM EQL HEMPTY THEN SYM_ZERO;
    IF .CODETOG THEN
	    SYM_CASE .ESC OF 
		SET
		GRETURN(.SYM);
		GEXIT(.SYM,.D);
		GXLOOP(.SYM,.D);
		GXBLOCK(.SYM,.D);
		GXCMPEX(.SYM,.D);
		GXCOND (.SYM,.D);
		GXSELECT(.SYM,.D);
		GXCASE(.SYM,.D);
		GXSET(.SYM,.D);
		TES;
    END;
GLOBAL ROUTINE SSPUNOP=
  BEGIN LOCAL TYPE,P;
    !THIS ROUTINE HANDLES SPECIAL UNARY OPERATORS(FUNCTIONS) IMPLEMENTED
    !TO ALLOW USE OF OPCODES SUCH AS JFFO AND MOVM AND ACCORDING TO USER PRESSURE.
    TYPE_.ST[.SYM<STEF>,1];
    HRUND();
    EXPRESSION(2);
    IF (P_.SYM) EQL HEMPTY THEN P_ZERO;
    IF .DEL<LEFTHALF> NEQ HROCLO THEN
      (RECOVER(.NDEL,44); RETURN ERRLEVEL_1)
%3.7%   ELSE IF .CODETOG THEN 
	% THE FOLLOWING 7 LINES ARE ADDED TO FIX BUG#4 %
				(
				 IF NOT LITP(.P) THEN
				  IF  .P<LSF> THEN
				   IF UPLEVELCHECK(.P) THEN
					P=.SYMVALUE;
				 SYM=GSPUNOP(.TYPE,.P);
				 );
    IF CORRECTP1() THEN FUTSYM_.SYM
    ELSE (RECOVER(.NFUTSYM,IF FUTAE() THEN 3 ELSE 12);
	  ERRLEVEL_1);
    HRUND()
  END;


ROUTINE SSPLF=
    BEGIN LOCAL T, O, P1, P2;
    !    THIS ROUTINE HANDLES THE COMPILATION OF THE SPECIAL
    !    CHARACTER HANDLING FUNCTIONS.
    !
    T_.ST[.SYM<STEF>,1];
    P1_P2_0;
    HRUND();
    EXPRESSION(2);
    IF (P1_.SYM) EQL HEMPTY THEN ERROR(.NSYM,43);
    IF .DEL<LEFTHALF> EQL HCOMMA THEN
	BEGIN
 	HRUND(); EXPRESSION(2);
	IF (P2_.SYM) EQL HEMPTY THEN ERROR(.NSYM,43);
	END;
    IF  .DEL<LEFTHALF> NEQ HROCLO 
	THEN (RECOVER(.NDEL,44);RETURN ERRLEVEL_1)
%3.7%   ELSE IF .CODETOG THEN 
	% THE FOLLOWING 9 LINES ARE ADDED TO FIX BUG#4 %
		BEGIN
		 INCR I FROM 0 TO 1 DO
		  ( IF NOT LITP(.P1[.I]) THEN
		     IF .P1[.I]<LSF> THEN
		      IF UPLEVELCHECK(.P1[.I]) THEN
			  P1[.I]=.SYMVALUE;
		  );
		 SYM=GSPLF(.T,.P1,.P2);
		END;
    IF CORRECTP1() 
	THEN FUTSYM_.SYM
	ELSE (RECOVER(.NFUTSYM,IF FUTAE() THEN 3 ELSE 12); ERRLEVEL_1);
    IF .T LSS 10 THEN
    IF .T GEQ 6 THEN FIXSIDEEFFECTS()
	ELSE IF NOT .T THEN FIXSIDEEFFECTS(); %5-16-77%
    HRUND();
    END;
%3.1%	GLOBAL ROUTINE SSELECT=
%V2H%    BEGIN LOCAL LLABIND, N;
    !
    !    THIS ROUTINE ANALYZES THE SYNTAX OF SELECT EXPRESSIONS
    !
    HRUND();
    N_0;
    IF .CODETOG THEN GSE0();
%V2H%	SETLABSIFNECESSARY(SELECTC);
    UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HCOMMA DO
	BEGIN
	    EXPRESSION(0); VTARGET_-1; SYM_GENCODE(.SYM,2);
	    IF .SYM EQL HEMPTY THEN SYM_ZERO;
	    IF .DEL<LEFTHALF> EQL HCOMMA THEN
		(N_.N+1; IF .CODETOG THEN GSE1(.SYM); HRUND());
	    FIXSIDEEFFECTS();
	    ERRLEVEL_0;
        END;
    IF .SYM EQL HEMPTY THEN (SYM_ZERO; ERROR(.NSYM,50));
%V2H%    IF .DEL<LEFTHALF> NEQ HOF THEN (RECOVER(.NDEL,45); RETURN(ERRLEVEL_1; KILLLABSIFNECESSARY));
%3.39%    IF .CODETOG THEN (GSE2(.N+1,.SYM); GTPURGE(0); GTINCR(); SAVRT(0));
    HRUND();
    FIXSIDEEFFECTS();
%V2H%    IF .DEL<LEFTHALF> NEQ HNSET THEN (RECOVER(.NDEL,46); RETURN(ERRLEVEL_1; KILLLABSIFNECESSARY));
    HRUND();
    UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HSEMCOL AND 
	.DEL<LEFTHALF> NEQ HCOLON AND .DEL<LEFTHALF> NEQ HALWAYS AND 
	.DEL<LEFTHALF> NEQ HOTHERWISE DO
	BEGIN
%3.39%  IF .DEL<LEFTHALF> EQL HOTHERWISE THEN (HRUND(); IF .CODETOG THEN (GSE3O(); CLEARSOME(); GTPURGE(1))) ELSE
%3.39%  IF .DEL<LEFTHALF> EQL HALWAYS THEN (HRUND(); IF .CODETOG THEN (GSE3A(); CLEARSOME(); GTPURGE(1))) ELSE
          BEGIN
  	EXPRESSION(0); VTARGET_-1; SYM_GENCODE(.SYM,1);
  	IF .SYM EQL HEMPTY THEN (ERROR(.NSYM,47); SYM_ZERO);
%3.39%	IF .CODETOG THEN (GSE3(.SYM); CLEARSOME(); GTPURGE(1))
        END;
%V2H%  	IF .DEL<LEFTHALF> NEQ HCOLON THEN (RECOVER(.NDEL,48); RETURN( ERRLEVEL_0; KILLLABSIFNECESSARY));
	HRUND();
	EXPRESSION(0); VTARGET_2; SYM_GENCODE(.SYM,2);
	IF .SYM EQL HEMPTY THEN SYM_ZERO;

	!OTHERWISE AND ALWAYS DON'T REQUIRE A FOLLOWING SEMICOLON.  IF IT
	!IS MISSING, PRINT A WARNING AND ASSUME IT IS THERE

	BEGIN
	IF .DEL<LEFTHALF> EQL HOTHERWISE OR
	   .DEL<LEFTHALF> EQL HALWAYS
	    THEN
	      BEGIN
		WARNEM(.NSYM,ERNOSEMI);
		IF .CODETOG THEN
%3.39%		  (GSE4(.SYM); CLEARSOME(); GTPURGE(1); EXITCOMPOUND[3])	!TO %A%
	      END;

	IF .DEL<LEFTHALF> EQL HSEMCOL THEN
%3.39%	    ( IF .CODETOG THEN (GSE4(.SYM); CLEARSOME(); GTPURGE(1)); HRUND())
	ELSE IF .DEL<LEFTHALF> NEQ HTESN  THEN EXITLOOP;
%A%	END;

	ERRLEVEL_0;
	END;
%V2H%    IF .DEL<LEFTHALF> NEQ HTESN THEN (RECOVER(.NDEL,49); RETURN (ERRLEVEL_0; KILLLABSIFNECESSARY));
%3.39%    IF .CODETOG THEN (SYM_GSE5(.SYM); RESRT(1); CLEARSOME(); GTPURGE(2); LIVR(.SYM); GTDECR());
    IF .FUTSYM EQL HEMPTY AND .FUTDEL<HCLASS> EQL CLOBRAC
	THEN FUTSYM_.SYM
	ELSE (IF FUTAE() THEN RECOVER(.NFUTDEL,3) ELSE RECOVER(.NFUTSYM,12); ERRLEVEL_1);
    IF .ERRLEVEL EQL 0 THEN HRUND();
%V2H%	KILLLABSIFNECESSARY;
    END;
%3.1%	GLOBAL ROUTINE SIF=
    BEGIN
%V2H%	LOCAL LLABIND;	!HOLDS INDEX TO LABEL CHAIN IF ANY
    !
    !    THIS ROUTINE COMPILES THE IF-THEN-ELSE FORM OF CONTROL EXPRESSION.
    !
%V2H%	ROUTINE CONSTIF(TRIP)=
	    BEGIN  LOCAL RESULT,SVTARGET;
	    IF .CODETOG THEN GCE0(0);  
	    IF NOT .TRIP THEN SHUTOFFCODE(); 
            SVTARGET=.VTARGET;
	    VTARGET = 0;		%9-19-77%
            HRUND();
            EXPRESSION(0);		%9-19-77%
	    IF  .SYM EQL HEMPTY THEN SYM_ZERO;
	    IF .TRIP 
		THEN (RESULT_.SYM; SHUTOFFCODE())
		ELSE TURNONCODE();
	    IF .DEL<LEFTHALF> EQL HELSE THEN
		BEGIN HRUND(); EXPRESSION(1); END;
	    IF .SYM EQL HEMPTY THEN SYM_ZERO;
	    IF NOT .TRIP THEN RESULT_.SYM ELSE TURNONCODE();
	    IF .CODETOG THEN SYM_GCE2(.RESULT,0);
		CODEPTR_LOCATE(ITEC,5);
		CLASSLAB();
		UNTEMPLATE();
		VTARGET=.SVTARGET
	  END;





%V2H%	  !IF WE HAVE LABELS ON THIS IF THEN ELSE, STORE SKELETON HEADER
%V2H%	  !IN LABEL STES.
        LOCAL SKIPTOG;
	LOCAL NESTEDIF;    EXTERNAL NOIFOPT;		%9-19-77%
	NESTEDIF=.NOIFOPT;				%9-19-77%
	SKIPTOG_.DEL<LEFTHALF> EQL HIFSKIP;
	IF .CODETOG THEN GITE0();
%V2H%	SETLABSIFNECESSARY(ITEC);	!IF THIS ITE LABELED, TURN LABELS ON.
	IF .NESTEDIF EQL 2 THEN NOIFOPT=1;		%9-19-77%
%V2H%	  HRUND();  EXPRESSION(0); VTARGET_-1; SYM_GENCODE(.SYM,2);
	NOIFOPT = 2;					%9-19-77%
	IF .SYM EQL HEMPTY THEN(ERROR(.NSYM,38); SYM_1) ELSE
	IF .DEL<LEFTHALF> EQL HTHEN AND LITP(.SYM) AND .CODETOG THEN
%V2H%	    RETURN( CONSTIF(LITV(.SYM));NOIFOPT=.NESTEDIF; KILLLABSIFNECESSARY);	%9-19-77%

	IF .CODETOG THEN ( GITE1(.SYM,.SKIPTOG); GTPURGE(0); GTINCR(); SAVRT(0));
	IF .DEL<LEFTHALF> NEQ HTHEN 
	    THEN RECOVER(.NDEL,39)
	    ELSE
		BEGIN HRUND(); EXPRESSION(2);
			IF .SYM EQL HEMPTY THEN SYM_ZERO;
			IF .CODETOG THEN (GITE2(.SYM);GTPURGE(1); RESRT(0))
		END;
	IF .DEL<LEFTHALF> NEQ HELSE 
	    THEN (IF .CODETOG THEN
		 (SYM_ZERO; SYM_GITE3(.SYM); RESRT(1);CLEARSOME();GTPURGE(2);LIVR(.SYM);GTDECR()))
	    ELSE
		BEGIN HRUND(); EXPRESSION(2);
		IF .CODETOG THEN
		    (SYM_GITE3(.SYM); RESRT(1); CLEARSOME(); GTPURGE(2); LIVR(.SYM);GTDECR());
		 END;
%V2H%	  KILLLABSIFNECESSARY;
	NOIFOPT = .NESTEDIF;				%9-19-77%
    END;
%3.1%	GLOBAL ROUTINE SDO=
	%PRINCIPLE: CONSIDER WHILE (OR UNTIL) AS A SPECIAL SORT OF
	COMMA AND READ UNTIL THE END OF THE WHOLE SO 
	EXPRESSION.
	1.  BOOK THAT THE ANALYSIS OF THE DO PART HAS STARTED
	(IN VARIABLE COM)
	2.  READ IN ORDERRTO START WITH THE DO EXPRESSION
	3.  VERY SIMILAR TO THE REP ROUTINE R10 %
%V2H%	BEGIN LOCAL LLABIND, COM, SORT; COM_0; IF .CODETOG THEN GDWU0();
%V2H%	SETLABSIFNECESSARY(DWUC);
	HRUND(); CLEARRTGT();
	EXPRESSION(1);
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .CODETOG THEN GDWU1(.SYM);
	FIXSIDEEFFECTS();
	SORT_.DEL<LEFTHALF>;
	IF .SORT NEQ HUNTLCLO  AND  .SORT NEQ HWHLCLO
%V2H%	    THEN (RECOVER(.NDEL,2); RETURN( ERRLEVEL_1; KILLLABSIFNECESSARY)) ELSE HRUND();
	EXPRESSION(1);
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .CODETOG THEN SYM_GDWU2(.SYM,.SORT EQL HWHLCLO);
	ERRLEVEL_0; CLEARRTGT();
%V2H%	KILLLABSIFNECESSARY;
END;



%3.1%	GLOBAL ROUTINE SWU=
	%ALMOST THE SAME AS SDO EXCEPT THAT DIRECT AT THE BEGINNING
	THE DISTINCTION IS FOUND BETWEEN WHILE AND UNTIL EXPRESSIONS.
	DO IS CONSIDERED AS SORT OF A COMMA%
%V2H%	BEGIN LOCAL LLABIND, SORT, COM;  SORT_.DEL<LEFTHALF>; COM_0;
%V2H%	IF .CODETOG THEN GWUD0(); SETLABSIFNECESSARY(WUDC); HRUND(); CLEARRTGT();
	EXPRESSION(0); VTARGET_-1; SYM_GENCODE(.SYM,1);
	IF .SYM EQL HEMPTY THEN (SYM_ZERO; ERROR(.NSYM,31));
	IF .CODETOG THEN GWUD1(.SYM,.SORT EQL HUNTIL);
	FIXSIDEEFFECTS();
	IF .DEL<LEFTHALF> EQL HDO
%V2H%	    THEN HRUND() ELSE (RECOVER(.NDEL,2); RETURN( ERRLEVEL_1; KILLLABSIFNECESSARY));
	EXPRESSION(1);
	IF .SYM EQL HEMPTY THEN SYM_ZERO;
	IF .CODETOG THEN SYM_GWUD2(.SYM);
	ERRLEVEL_0; CLEARRTGT();
%V2H%	KILLLABSIFNECESSARY;
END;
%3.1%	GLOBAL ROUTINE SPAROPEN =
BEGIN 
	%THIS ROUTINE ACTS AS A SWITCH TO 
	THE APPROPRIATE ROUTINE TO HANDLE: (1)USER FUNCTION/
	ROUTINE CALLS, OR (2) SPECIAL FUNCTIONS.%
	
	IF .SYM<LSF> THEN
		BEGIN
		IF .ST[.SYM<STEF>,0]<TYPEF> EQL MACHT THEN SML() ELSE
		IF .ST[.SYM<STEF>,0]<TYPEF> EQL SPLFT THEN SSPLF() ELSE
		IF .ST[.SYM<STEF>,0]<TYPEF> EQL SPUNOPT THEN SSPUNOP() ELSE
			 SUSERCALL(0)
		END ELSE SUSERCALL(0);
END;

ROUTINE SML=
BEGIN LOCAL OP, N, P1,P2, P3, P4;
	%THIS ROUTINE HANDLES THE ANALYSIS OF THE MACHINE LANGUAGE
	SPECIAL FUNCTIONS. %
	OP_.ST[.SYM<STEF>,1]; N_P1_P2_P3_P4_0; HRUND();
	UNTIL .DEL<HCLASS> EQL CLOBRAC AND .DEL<LEFTHALF> NEQ HCOMMA DO
	    BEGIN
		EXPRESSION(2);
		IF .DEL<LEFTHALF> EQL HCOMMA
		    THEN (P1[.N]_.SYM; N_ .N+1; HRUND());
		ERRLEVEL_0;
	    END;
	P1[.N]_.SYM; ! IF NOT LITP(.P1) THEN ERROR(.NSYM,#146);
	% THE FOLLOWING 6 LINES ARE ADDED TO FIX REGISTER
	 DECLARATIONS AND USAGE IN NESTED GLOBAL ROUTINES 12-27-77 %
	IF NOT LITP(.P1) THEN
	 IF .P1<LSF> THEN
	  BEGIN
	   IF UPLEVELCHECK(.P1) THEN P1=.SYMVALUE
				ELSE ERROR(.NSYM,#146);
	  END;
	IF .DEL<LEFTHALF> EQL HROCLO
		THEN (IF .CODETOG THEN 
	% THE FOLLOWING 10 LINES ARE ADDED TO FIX BUG#4 %
					BEGIN
					 INCR I FROM 0 TO 2 DO
					  ( IF NOT LITP(.P2[.I]) THEN
					     IF .P2[.I]<LSF> THEN
						IF UPLEVELCHECK(.P2[.I]) THEN
						 P2[.I]=.SYMVALUE;
					  );
					  SYM=GML(.OP,.P1,.P2,.P3,.P4)
					END 
		     )
		ELSE (RECOVER(.NDEL,#150); RETURN ERRLEVEL_1);
	IF CORRECTP1() THEN FUTSYM_.SYM
		ELSE(RECOVER(.NFUTSYM,IF FUTAE() THEN 3 ELSE 12); ERRLEVEL_1);
	HRUND();
END;
%3.1%	GLOBAL ROUTINE DECLTEMPREG(SYMBLEX,SWIT)=
	% THIS ROUTINE DECLARES (AND UN-DECLARES) A TEMPORARY
	REGISTER FOR USE IN INCR-DECR LOOPS. SWIT=1 IMPLIES
	MAKE DECLAR,SWIT=0 SIMPLY DOES A BLOCKPURGE. IN CASE
	OF A DECLARATION WE RETURN THE LEXEME FOR THE NEW 
	REGISTER VARIABLE.
	%
	BEGIN LOCAL L1;
	IF .SWIT THEN
	  BEGIN BLOCKLEVEL_.BLOCKLEVEL+1; L1_.REALS;
	    IF .SYMBLEX<LSF> NEQ 1 AND .L1 EQL 0 THEN ERROR(.NSYM,#36) ELSE
		BEGIN
		ACCUM_.ST[.L1,2]; ACCUM+1_.ST[.L1,3];
		L1_STINSERT(.UNDECLEX,0);
		ST[.L1,0]<TYPEF>_REGT;
		SYMBLEX_ST[.L1,1]_LTINSERT(ACQUIRE(-.L1,1)<0,36>);
		ST[.L1,1]<NRF>_1;
		SYMBLEX<VEF>_1;
		.SYMBLEX
		END
	  END ELSE BLOCKPURGE(BLOCKLEVEL_.BLOCKLEVEL-1)
	END;
%%
%    PLIT SYNTAX PROCESSING ROUTINES.  THE SYNTAX FOR PLITS IS AS
  FOLLOWS:

    <PLIT> ::= PLIT <PLITARG>
    <PLITARG> ::= <LOAD TIME EXPRESSION> !
                  <LONG STRING> !
                  <TUPLE>
    <TUPLE> ::= (<TUPLE ITEM LIST>)
    <TUPLE ITEM LIST> ::= <TUPLE ITEM> !
                          <TUPLE ITEM>,<TUPLE ITEM LIST>
    <TUPLE ITEM> ::= <LOAD TIME EXPRESSION> !
                     <LONG STRING> !
                     <DUPLICATION FACTOR>:<PLITARG>
    <DUPLICATION FACTOR> ::= <COMPILE TIME EXPRESSION>

     [NOTE: <LOAD TIME EXPRESSION> ::= <PLIT> ! ...]

     GENERALLY PLITS ARE TREATED EXACTLY AS GLOBALS.  A FAKE SYMBOL
  TABLE ENTRY OF TYPE "PLITT" IS ENTERED IN THE SYMBOL TABLE;
  ITS ADDITIONAL INFORMATION WORD IS ITS OFFSET FROM THE PLIT REGION
  BASE.  OF COURSE, A NEW RELOCATION TYPE FOR PLITS IS REQUIRED.

     INTERNALLY THE ELEMENTS OF ALL PLITS ARE HUNG OFF A HEADER
  POINTED TO BY "PLHEAD".  EACH ELEMENT IS A POINTER TABLE TYPE
  ELEMENT, WITH TWO EXCEPTIONS:

     1. LITERALS ARE ALSO PUT IN, WITH RELOCATION TYPE "NORELOC";
     2. DUPLICATED SUBLISTS ARE ENTERED AS 2 CELL HEADERS; WORD 2
        CONTAINS THE REPETITION FACTOR.

     "PLHEAD" IS PROCESSED BY THE LOADER INTERFACE AT THE END OF
  THE COMPILATION.  THE SYNTAX PROCESSING ROUTINES FOR THE PLITS
  GENERALLY CORRESPOND TO THE NON-TERMINAL PRODUCTIONS OF THE SYNTAX.
  EACH ROUTINE IS PASSED A HEADER ONTO WHICH THE RESULTING CHAIN OF
  POINTER TYPE ENTRIES IS LINKED.  EACH RETURNS THE LENGTH OF THE
  SPACE OCCUPIED BY THE PARTICULAR NON-TERMINAL IN ORDER THAT THE
  "PLNEXT" (NEXT PLIT OFFSET) MAY BE UPDATED CORRECTLY.
%
%%
  MAP STVEC PLHEAD;   ! CT HEADER FOR THE SYSTEM PLITS

  FORWARD PLITARG, PLITLEX, FINNAMES;
  GLOBAL ROUTINE SPLIT1(A) =
    BEGIN
! IF .A EQL  0 THEN IT IS PLIT OR UPLIT.
! IF .A EQL 2 THEN CALLED FROM OWNEQL.
! IF .A EQL 1 THEN CALLED FROM GLOEQL.
! (5.200.13) INTRODUCES  UPLIT, UNCOUNTED PLIT
! (5.200.13)      BIND PLITLENGTH=1;
%5.200.13%	LOCAL PLITLENGTH;

      LOCAL STVEC TEMPHEAD:NEXTCELL:FIRSTCELL, OFFST, LOCGPV, NAMESINDEX;
      PUSHGPV(0,PLBOOL)_1;
      NAMESINDEX_0;
      TEMPHEAD_HEADER(0,0,0);

            IF .A EQL 0 THEN
%5.200.13%	IF .DEL<LEFTHALF> THEN PLITLENGTH_0	! UPLIT IS ODD
%5.200.13%			  ELSE PLITLENGTH_1;	!  PLIT IS EVEN

%5.200.13%   IF (.PLITLENGTH EQL 1 OR .A GEQ 1) THEN FIRSTCELL_NEWBOT(.TEMPHEAD,1);
      OFFST_PLITARG(NAMESINDEX,.TEMPHEAD,0);
%5.200.13%      IF .NAMESINDEX NEQ 0 THEN FINNAMES(.NAMESINDEX,.PLITLENGTH);
%5.200.13%      IF (.PLITLENGTH EQL 1  OR .A GEQ 1) THEN FIRSTCELL[1]_.OFFST;
         IF .A EQL 0 THEN (
%5.200.13%      SYM_PLITLEX(.PLNEXT+.PLITLENGTH);
%5.200.13%      PLNEXT_.PLNEXT+.OFFST+.PLITLENGTH;
                SYM<POSNSIZEF>_36);
  CASE .A OF SET
      PUSHBOT(.PLHEAD,.TEMPHEAD);
      PUSHBOT(.GLOHEAD,.TEMPHEAD);
      PUSHBOT(.OWNHEAD,.TEMPHEAD)
   TES;
      FLATTEN(.TEMPHEAD);
      POPGPV(0,PLBOOL);
     IF .A EQL 0 THEN .SYM ELSE .FIRSTCELL
    END;


  GLOBAL ROUTINE SPLIT=SPLIT1(0);
%5.200.13%	  ROUTINE FINNAMES(NAMESINDEX,PLITLSW)=	!FINISH NAMES BINDING IN PLITS
    BEGIN
      LOCAL L,LL;
%5.200.16%	LOCAL GSW;
	WHILE .NAMESINDEX NEQ 0 DO
	  BEGIN
%5.200.16%	    LL_.ST[.NAMESINDEX,1]<18,15>;
!THE LEFT HALF HOLDS A FORWARD INDEX AND, NOW (5.200.16), A GLOBAL SWITCH
%5.200.16%		GSW_.ST[.NAMESINDEX,1]<35,1>;
	    ST[.NAMESINDEX,1]<LEFTHALF>_0;
%5.200.13%	    ST[.NAMESINDEX,1]_.ST[.NAMESINDEX,1]+.PLNEXT+.PLITLSW;
%5.200.16%	ST[.NAMESINDEX,0]<TYPEF>_
%5.200.16%		IF .GSW THEN GPLITT ELSE PLITT;

!  %5.200.16%	    IF .ST[.NAMESINDEX,0]<TYPEF> EQL GPLITT
%5.200.16%	IF .GSW
		THEN DEFGLLEX(.NAMESINDEX);
	    NAMESINDEX_.LL
	  END
    END;
  FORWARD TUPLEITEM, LSORLE;
  ROUTINE PLITARG(NAMESINDEX,HEAD,DUPPLITFL) =
    !HEAD IS INDEX TO LIST OF PLIT ARGS
    !NAMESINDEX CONTAINS ADDRESS OF WORD TO RECEIVE STINDEX OF NAME TO
    !BE BOUND VIA A NAMES OR INDEXES BIND
    !DUPPLITFL EQL 1 <=> DUPPLICATION FACTOR MAKES A NAMES OF
    !INDEXES BIND ILLEGAL AT THIS POINT.
    BEGIN
      HRUND();
      IF .SYM EQL HEMPTY AND .DEL<LEFTHALF> EQL HROPEN
        THEN
          BEGIN
            LOCAL LENTH,	!LENGTH OF PLIT IN WORDS, NOT COUNTING PLIT[-1]
		  LNAMESINDEX,	!INDEX TO NAMES BIND ST ENTRY CHAIN
		  LNSYM;	!CONTAINS .NSYM IN CASE WE MUST HRUND ON A GLOBAL BIND
	    REGISTER PLITFLAGS,	!PLIT FLAGS EXPLAINED IN MACROS BELOW
		     RSTE;	!STE INDEX OF NAME TO BE BOUND
	   MACRO CHAIN(X)=ST[X,1]<18,18>_.LNAMESINDEX;
			   LNAMESINDEX_X;$;

	    MACRO NAMESFL=PLITFLAGS<0,1>$,	!1 -> NAMES BIND, 0-> INDEXES BIND
		  GLOBALFL=PLITFLAGS<1,1>$;	!1<-> GLOBAL BIND
            PLITFLAGS_LNAMESINDEX_LENTH_0;
%A%         DO (HRUND();

	  !LOOP UNTIL THERE ARE NO MORE NAMES OR INDEXES BINDS
%B%	  WHILE (NAMESFL_(.DEL<LEFTHALF> EQL HNAMES)) OR
			 (.DEL<LEFTHALF> EQL HINDEXES) OR
			 (GLOBALFL_(.DEL<LEFTHALF> EQL HGLOBALLY))
	   DO
	    BEGIN
	      BEGIN
		LNSYM_.NSYM;
		IF .DUPPLITFL THEN (WARNEM(.LNSYM,ERNOBINDDUP);EXITCOMPOUND[2]);	%C%
		IF NOT .SYM<LSF> THEN (WARNEM(.LNSYM,ERNONAME); EXITCOMPOUND[2]);	%C%
		RSTE_.SYM<STEF>;	!STE INDEX OF NAME TO BE BOUND
%2.20%		IF .GLOBALFL THEN HRUND();	!TO MOVE OVER GLOBALLY LEXEME

		IF NOT ((.DEL<LEFTHALF> EQL HINDEXES) OR (NAMESFL_(.DEL<LEFTHALF> EQL HNAMES)))
		  THEN (WARNEM(.NDEL,ERDMBIN); EXITLOOP %EXIT LOOP -B-%);

		IF .ST[.RSTE,0]<BLF> EQL .BLOCKLEVEL	!IF NAME ALREADY DECLARED AT THIS BLOCK LEVEL
		  THEN (IF .ST[.RSTE,0]<TYPEF> NEQ UNDEDT THEN (WARNEM(.LNSYM,ERNMPREV); EXITCOMPOUND[3]))	%C%
		  ELSE RSTE_DECSYQ(.RSTE,0,0);

%2.34%		IF .GLOBALFL THEN IF GSTINSERT(.RSTE) NEQ 0
%2.20%		  THEN (WARNEM(.LNSYM,ERALDECGL); GLOBALFL_0);

		ST[.RSTE,1]_.LENTH;	!SAVE OFFSET IN ALL CASES


		ST[.RSTE,0]<TYPEF>_CASE .PLITFLAGS OF SET
		ABSOLUTET;				!INDEXES
%5.200.16%	(CHAIN(.RSTE);%PLITT% UNDEDT);			!NAMES
		(DEFGBC(.RSTE,.LENTH);GABSOLUTET);	!GLOBALLY INDEXES
%5.200.16%	(CHAIN(.RSTE);ST[.RSTE,1]<35,1>_1;%GPLITT%  UNDEDT)			!GLOBALLY NAMES
		TES
%C%	      END;
	      HRUND();
	    END;	!OF WHILE-DO LOOP %B%
	    .NAMESINDEX_.LNAMESINDEX;
	     LENTH_.LENTH+TUPLEITEM(.HEAD);)	!END OF DO PORTION OF DO-WHILE LOOP
              WHILE .DEL<LEFTHALF> EQL HCOMMA;	!END OF DO-WHILE LOOP %A% 
            IF .DEL<LEFTHALF> NEQ HROCLO OR .FUTSYM NEQ HEMPTY 
              THEN RETURN RECOVER(.NDEL,ERSYPLMRP);
            HRUND();
            .LENTH
          END
        ELSE LSORLE(.HEAD)
    END;
 ROUTINE TUPLEITEM(HEAD) =
    BEGIN
      EXPRESSION(1);
      IF .DEL<LEFTHALF> EQL HCOLON
        THEN
          BEGIN
            LOCAL LEN, STVEC NEWHEAD, NAMESINDEX;
            IF NOT LITP(.SYM) THEN (ERROR(.NSYM,ERSMPLNLI); SYM_ZERO);
            NEWHEAD_HEADER(2,0,1);
           !THE FOLLOWING THREE LINES WILL CHECK FOR NEGATIVE
           !RELICATION COUNT IN A PLIT AND WARN THEM. 3-28-77
            LEN_LITV(.SYM);
            IF .LEN LSS 0 THEN (LEN_0;WARNEM(.NSYM,#763));
            NEWHEAD[2]<RIGHTHALF>_.LEN;
            PUSHBOT(.HEAD,.NEWHEAD);
            LEN_.LEN*PLITARG(NAMESINDEX,.NEWHEAD,1);
	    .LEN
          END
        ELSE LSORLE(.HEAD)
    END;

  FORWARD LEXTOP;
  MACRO UNDER(A,B)=
    BEGIN
      MAP STVEC A:B;
      CT[.A[1]<PREVF>,0]<NEXTF>_.B[1]<NEXTF>;
      CT[.B[1]<NEXTF>,0]<PREVF>_.A[1]<PREVF>;
      A[1]<PREVF>_.B[1]<PREVF>;
      CT[.B[1]<PREVF>,0]<NEXTF>_.A;
      RELEASESPACE(.B,1)
    END$;

  ROUTINE LSORLE(HEAD)=
%5.200.18%BEGIN LOCAL WHICHB;
    IF .STRHED NEQ 0
      THEN
        BEGIN
          LOCAL RLEN, LSHEAD;
          LSHEAD_.STRHED<RIGHTHALF>;
          RLEN_.STRHED<LEFTHALF>;
          STRHED_0;
%5.200.34 - CHANGE FOR UPLIT... %
	IF .CT[.HEAD,1]<NEXTF> EQL .HEAD THEN
		BEGIN
		LOCAL FSW,LSW;
		FSW=.CT[.LSHEAD,1]<NEXTF>;
		LSW=.CT[.LSHEAD,1]<PREVF>;
		CT[.HEAD,1]<NEXTF>=.FSW;
		CT[.FSW,0]<PREVF>=.HEAD;
		CT[.HEAD,1]<PREVF>=.LSW;
		CT[.LSW,0]<NEXTF>=.HEAD;
		RELEASESPACE(.LSHEAD,1);
		END
         ELSE  UNDER(HEAD,LSHEAD);
% .... 5.200.34%
          .RLEN
        END
      ELSE
%5.200.18%	(WHICHB_WHICHBIND();
%5.200.18%	IF .WHICHB GTR 1 THEN WHICHB_3-.WHICHB;
%5.200.18%	IF .WHICHB EQL 0
%5.200.18%    THEN  (ERROR(.NSYM, ERSMPLNLO); LEXTOP(.HEAD,ZERO)) ! 0 - RUNTIME CODE MADE / 3 - RUNTIME ADDRESS
%5.200.18%	ELSE  (LEXTOP(.HEAD,.SYM)))			! 1 - LITERAL / 2 - LOADTIME ADDRESS
%5.200.18%END;
  ROUTINE LEXTOP(HEAD,LEX) =
    BEGIN
      LOCAL STVEC CELL, CODE3;
      CELL_GETSPACE(1);
      CELL[0]_.CELL^15+.CELL;
      IF .LEX<LSF>
        THEN
          BEGIN
            CODE3_
		IF PTRTYPP(.LEX)
		  THEN MADDRFRPTRTYP(.LEX)
		  ELSE FSA(.LEX<STEF>);
            CELL[0]<RELOCF>_.CODE3<RELOCF>;
            CELL[1]_
%3.40%		IF PTRTYPP(.LEX)
		  THEN VALPTRTYP(.LEX<STEF>)
		  ELSE .LEX<POSNSIZEF>^24 OR (.CODE3 AND IXYM);
          END
        ELSE
          BEGIN
            CELL[0]<RELOCF>_NORELOC;
            CELL[1]_LITV(.LEX);
          END;
      PUSHBOT(.HEAD,.CELL);
      1
    END;
  ROUTINE PLITLEX(OFFST)=
  BEGIN
    ACCUM[0]_0; ACCUM[1]_-1;
    (STINSERT((PLITT^TYPEFP)+LSM,.OFFST)+LSM)
  END;



!END OF H1SYNT.BLI