*DECK             BRKPT 
USETEXT   TSOURCE 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TCOM37Q 
USETEXT   TCOM39Q 
USETEXT   TCOM78Q 
USETEXT   TC7DECS 
USETEXT   TCEXEC
USETEXT   TCOM39
PROC BRKPT; 
                                        #BRKPT CONTROLS THE GENERATION #
                                        # OF ALL "BREAKPOINT" OPERA-   #
                                        # TORS. AS SUCH, IT IS A       #
                                        # COLLECTION OF INDIVIDUAL     #
                                        # ROUTINES, ONE FOR EACH OPERA-#
                                        # TOR. ADDITIONALLY, IT SERVES #
                                        # AS A CONVENIENT POINT TO     #
                                        # PURGE VALUS FROM THE DEAD    #
                                        # VALU LIST.                   #
BEGIN 
  
*CALL COMEX 
  
  
  
#     DEFS                                                             # DON/D
                                                                         DON/D
      DEF  OPTIONA  #B<59-"C">OPTION NQ 0#;                              DON/D
     # INDEX SWITCH RANGE CHK OPTION #
      DEF  OPTIONB  #B<59-"D">OPTION NQ 0#;                              DON/D
#     PNOTT- GENERATE POINTS-NOT-TESTED INTERFACE CODE IF NECESSARY    # DON/D
          DEF PNOTT                                                      DON/D
#     IF B<59-"K">OPTION NQ 0 THEN                                       DON/D
          ICFGEN(QICFOP"PCAL", PSCPRC("SYMCK$"),0) #;                    DON/D
      DEF J833 #833#;              # SYMABT DIAGNOSTIC 833             # BRKPT
      DEF J837 #837#;              # SYMABT DIAGNOSTIC 837             # BRKPT
      DEF J838 #838#;              # SYMABT DIAGNOSTIC 838             # BRKPT
      DEF J840 #840#;              # SYMABT DIAGNOSTIC 840             # BRKPT
  
  
  
  
#     LOCAL DATA                                                       # DON/D
                                                                         DON/D
ITEM TSSTI,TSSTJ,TSSTK,TSSTL; 
ITEM G0TOI; 
    ITEM LABLI; 
ITEM
SWCHNM,       #SWITCH NAME# 
      SWCHNM$,    #ERROR SUBROUTINE#
NOSP I=-1,    #NUMBER OF SWITCH POINTS# 
SWCHLB,       #SWITCH LABEL#
SWCHN,        # HI BOUNDS TEST VALUE #
SWCHI,SWCHJ,SWCHK;                                                       JANDRE 
      ITEM WHERE$ C(10)= "LINE NNNN.";                                   DON/D
ITEM INVF1 U=0; 
ITEM INVF2 U=0; 
ITEM  INVTI I=0, INVTJ I=0; 
ITEM FLSCPX I=0; #FOR LOOP SCOPE INDEX# 
ARRAY [1:26]S(1); ITEM FLSCPL; #FOR LOOP SCOPE LABEL# 
ITEM SLOPI; 
        ITEM MYNE  ;
      ITEM  DVSPI, DVSPJ, DVSPK, DVSPL; 
ITEM PRGSW B=FALSE; 
ITEM PROGI,      #FILE ENTRY# 
     PROGJ,      #ADCON ENTRY#
     PROGK,      #DEVICE NAME#
     PROGL  I=0; #FIRST ADCON PTR#
ITEM PROGM,PROGN; 
ITEM
    PCALI, #PROC NAME ENTRY#
    PCALJ, #PARAMETER TRIAD#
    PCALK, #PCAL/PLST TRIAD#
    PCALL, #PARAMETER COUNTER#
    PCALN, #TEMP RELEASE CHAIN HEAD#
    PCALO, #PARAMETER LABEL ENTRY#
    PCALP, #TEMP ENTRY FOR PARAMETER VALUE# 
    PCALT,
    PCALU, #ADCON COUNTER#
    PCALV;
      ITEM  SWIGNL; 
      ITEM SWCHX I;   #XTRN OF SWITCH I.E. LOCAL ,XREF OR XDEF#          NEWFEAT
    ITEM ENTRITN; 
  
  
  
  
#     XDEFS                                                            # DON/D
                                                                         DON/D
    XDEF FUNC ADCGEN; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     XREFS                                                            # DON/D
                                                                         DON/D
    XREF PROC ADCNO;
    XREF PROC ADCON;
      XREF PROC BINDEC;                                                  DON/D
    XREF PROC CALOC;
    XREF FUNC CLABL;
    XREF PROC CLSS; 
    XREF PROC CODE; 
    XREF PROC DHASH;
    XREF PROC DPOSIT; 
    XREF PROC DMPTRD; 
    XREF PROC EXPGEN; 
    XREF FUNC FADCON; 
    XREF PROC FILTRD; 
    XREF PROC FIND; 
    XREF FUNC FYLSTS; 
    XREF PROC GETIL;
    XREF FUNC GETRD;
    XREF FUNC GTFW; 
    XREF PROC IADCON; 
    XREF PROC ICFGEN; 
    XREF PROC ICFGNR; 
    XREF PROC ICFPUT; 
    XREF FUNC IHASH;
    XREF FUNC KFIND;
    XREF PROC LOAD; 
    XREF FUNC MSKGEN; 
    XDEF FUNC PLNG; 
    XREF FUNC PLABL;
    XREF PROC POST; 
    XREF FUNC PSCARY; 
    XREF FUNC PSCPRC; 
    XREF FUNC PSICON; 
    XREF PROC REPRC;
    XREF PROC SADCON; 
    XREF PROC SYMABTL;                                                   BRKPT
    XREF FUNC TMPGEN; 
    XREF PROC TMPINT; 
    XREF PROC TMPRLS; 
          XREF PROC SLOD  ; 
      XREF FUNC KCT00;
      XREF PROC SAVESV; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     SWITCHES                                                         # DON/D
                                                                         DON/D
    SWITCH BRKPTSW:QILOP
              TSST:TSST,
              LABL:LABL,
              G0TO:GOTO,
              SPRC:SPRC,
              EPRC:EPRC,
              RTRN:RTRN,
              ENTR:ENTR,
              PROG:PRGM,
              ST0P:STOP,
              PCAL:PCAL,
              JOVY:CCAL                                                  JANDRE 
              ,REPL:REPL
              ,SLOP:SLOP
              ,ENDX:ENDL
              ,INVI:INVI
              ,INSP:INSP
              ,INSM:INSM
              ,INSD:INSD
              ,INVT:INVT
           ,VALD:VALD 
              ,PTRM:PTRM
              ,SWCH:SWCH
              ,ENDS:ENDS
              ,SWPT:SWPT
              ,GSWP:GSWP
              ,JOVY:SIVT                                                 JANDRE 
              ,JOVY:GISP                                                 JANDRE 
              ,SSWC:SSWC
              ,JOVY:ISWC                                                 JANDRE 
              ,PAUS:PAUS
              ,JOVY:CNTL                                                 JANDRE 
              ,JOVY:CTLD                                                 JANDRE 
              ,FRES:FRES
              ,JOVY:SJOV                                                 JANDRE 
              ,SWAP:SWAP
              ,JOVY:ICAL                                                 JANDRE 
              ,DEADS:DEAD 
              ; 
    SWITCH TSSTSW:QRLTL 
              TSSTEQ:EQ,
              TSSTNQ:NQ,
              TSSTLS:LS,
              TSSTGR:GR,
              TSSTLQ:LQ,
              TSSTGQ:GQ,
              TSSTTR:TR,
              TSSTFL:FL;
CONTROL EJECT;
FUNC ADCGEN((A),(B));  # ADCON GENERATOR #
    BEGIN 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     LOCAL DATA                                                       # DON/D
                                                                         DON/D
    ITEM A, #ALNK OBJECT# 
         B; #DSPL#
    ITEM I; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
    POST(NONAM,ADCN$W,I); 
    CLAS[I]=S"ADCN";
    POSI[I]=S"LOWER"; 
    ALNK[I]=A;
    DSPL[I]=B;
    LOCN[I]=SSIZ[APLC]; 
    SSIZ[APLC]=SSIZ[APLC]+1;
    ASEQ[LENT[APLC]]=I; 
    LENT[APLC]=I; 
    ADCGEN=I; 
    IF CLAS[A] EQ S"CONS" THEN CALOC(A);
    END 
CONTROL EJECT;
 FUNC NULLAB; 
  BEGIN 
       #  GET AN UNDECLARED LABEL FOR AN UNSET SWITCH POINT   # 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     LOCAL DATA                                                       # DON/D
                                                                         DON/D
   ITEM LAB =0; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
     IF LAB EQ 0 THEN 
       BEGIN
       LAB = PLABL; 
       UNDEC[LAB] = TRUE; 
       END
     NULLAB = LAB;
   END
      CONTROL EJECT;
PROC JPINS((A)); #GENERATE JUMP INSTRUCTION FOR SWITCH #
    BEGIN 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     LOCAL DATA                                                       # DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
    ITEM A;  # CLAS"LABL" SYMBOL TABLE POINTER #
    ITEM HALF I = 0;   # 0 = LEFT HALF, 1 = RIGHT HALF #
    PROC JPINSA;
         BEGIN
         CF00[CFIX] = 0;
      CFOP[CFIX] = QCFOP"EQ";                                            DON/D
         CFST[CFIX] = A;
      IF A EQ 0 THEN IF OPTIONA THEN
          CFST[CFIX] = SWCHNM$; ELSE
         CFST[CFIX] = NULLAB; 
         CODE;
         END
    IF OPTIONB THEN 
         BEGIN  # SWITCH POINTS PACKED TWO PER WORD # 
         IF HALF EQ 0 THEN
              BEGIN  # LEFT HALF OF WORD #
              CF00[CFIX] = 0; 
              CFOP[CFIX]=QCFOP"PL"; 
              CFST[CFIX] = A; 
      IF A EQ 0 THEN IF OPTIONA THEN
          CFST[CFIX] = SWCHNM$; ELSE
         CFST[CFIX] = NULLAB; 
       CFI[CFIX] = 0 ;
              CFJ[CFIX] = 1;
              CODE; 
              HALF = 1; 
              RETURN; 
              END 
JP00:    # RIGHT HALF OF WORD # 
         JPINSA;
         HALF = 0;
         ADCNL = ADCNL +1;
         SSIZ[CSLC]=SSIZ[CSLC]+1; 
         RETURN;
         END
    JPINSA; 
    GOTO JP00;
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
ENTRY PROC FJPINS((A)); 
    IF OPTIONB AND HALF NQ 0 THEN GOTO JP00;
    END 
CONTROL EJECT;
PROC GTNP; #GETS THE NEXT PARAMETER#
    BEGIN 
    PCALV=PCALK;
    IF PCALU EQ 0 THEN PCALV=PCALJ; 
    PCALK=NXOP[PCALV];
    PCALJ=ROPD[PCALK];
    PCALU=PCALU+1;
    PCALL=PCALL-1;
$BEGIN
    DMPTRD(PCALJ);
    DMPTRD(PCALK);
$END
    END 
CONTROL EJECT;
PROC IGTNP; #INITIALIZES GTNP PROC# 
    BEGIN 
    PCALK=OOIX; #PCAL TRIAD#
    PCALJ=ROPD[OOIX]; #1ST PARAMETER TRIAD# 
    PCALL=1; #PARAMETER COUNT#
IG00: 
    IF OPTR[PCALJ] EQ QILOP"PLST" THEN
         BEGIN #MORE PARAMETERS#
         PCALL=PCALL+1; 
         PCALJ=LOPD[PCALJ]; 
         GOTO IG00; 
         END
    IF OPTR[PCALJ] EQ QILOP"NULL" THEN PCALL=0; 
    PCALU=0; #1ST PARAMETER FLAG# 
$BEGIN
    DMPTRD(PCALJ);
    DMPTRD(PCALK);
$END
    END 
CONTROL EJECT;
FUNC PLNG((I));  #RETURNS LENGTH IN WORDS OF I, I= SYMBL TBL PTER TO OB#
BEGIN 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
#     LOCAL DATA                                                       # DON/D
                                                                         DON/D
    ITEM I,J; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
    J=TYPE[I];
    PLNG=1; 
           IF BYTATR[J] AND CLAS[I] NQ S"LABL" AND CLAS[I] NQ S"PROC" 
                THEN
              PLNG = (NBYT[I] + 9 ) / 10; 
END 
CONTROL EJECT;
                                                                         DON/D
#     THIS IS THE BEGINNING OF THE CODE FOR BRKPT.  IT IS SIMPLY A     # DON/D
#     SWITCH ON THE TRIAD OPERATOR                                     # DON/D
                                                                         DON/D
$BEGIN
      DMPTRD(OOIX);          # FORMAT AND PRINT TRIAD ENTRY, IF WANTED #
$END
  
    DVSPI=DVSP; 
    GOTO BRKPTSW[OPTR[OOIX]]; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
TSST: #CONDITIONAL BRANCH#
    TSSTI=LOPD[OOIX]; 
    TSSTJ=MEMR[ROPD[OOIX]]; #LABL#
    EXPGEN(TSSTI); #GENERATE BOOLEAN VALUE# 
    TSSTK=MEMR[TSSTI]; #B.V. INSTRUCTION PTR# 
    TSSTL=RLTL[TSSTI];
    IF $TST[TSSTI] THEN 
         BEGIN #SIGN TEST#
         TSSTI=SCOD[TSSTL]; 
         IF TSSTI NQ 0 THEN ICFGEN(TSSTI,TSSTJ,TSSTK);
         GOTO BRKRT;
         END
    GOTO TSSTSW[TSSTL]; 
                                                                         DON/D
TSSTEQ: 
    ICFGEN(QICFOP"NZ",TSSTJ,TSSTK); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
TSSTNQ: 
    ICFGEN(QICFOP"ZR",TSSTJ,TSSTK); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
TSSTLS: 
    ICFGEN(QICFOP"PL",TSSTJ,TSSTK); 
    IF NOT(TTST[TSSTI] OR B<59-"<">INTOPS NQ 0) THEN
         BEGIN
         ICFGEN(QICFOP"ZR",TSSTJ,TSSTK);
         IF CLAS[TSSTJ] EQ S"LABL" THEN 
         LREF[TSSTJ]=LREF[TSSTJ]+1; 
         END
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
TSSTGR: 
    ICFGEN(QICFOP"NG",TSSTJ,TSSTK); 
    ICFGEN(QICFOP"ZR",TSSTJ,TSSTK); 
    IF CLAS[TSSTJ] EQ S"LABL" THEN
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    LREF[TSSTJ]=LREF[TSSTJ]+1;
    GOTO BRKRT; 
                                                                         DON/D
TSSTLQ: 
    ICFGEN(QICFOP"ISUB",PZERO,TSSTK); 
    ICFGEN(QICFOP"NG",TSSTJ,ICFPTR);
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
TSSTGQ: 
    IF NOT(TTST[TSSTI] OR B<59-"<">INTOPS NQ 0) THEN
         BEGIN
         ICFGEN(QICFOP"IADD",TSSTK,PZERO);
         TSSTK=ICFPTR;
         END
    ICFGEN(QICFOP"NG",TSSTJ,TSSTK); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
TSSTTR: #FALL-THRU# 
    IF LREF[TSSTJ] LQ 0 
         THEN LREF[TSSTJ] = 0;
         ELSE LREF[TSSTJ] = LREF[TSSTJ] - 1;
    GOTO BRKRT; 
                                                                         DON/D
TSSTFL: #UNCONDITIONAL BRANCH#
    ICFGEN(QICFOP"JP",TSSTJ,0); 
    GOTO BRKRT; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
LABL: 
    LABLI=MEMR[LOPD[OOIX]]; 
    LBIL[LABLI]=F; #INITIALIZE FALSE,ENDL SETS# 
    ICFGEN(QICFOP"LABL",LABLI,0); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
G0TO: 
    G0TOI=MEMR[LOPD[OOIX]]; 
    IF FPRI[G0TOI] NQ S"NULL" THEN ICFGEN(QICFOP"RTRN",G0TOI,0);
    ELSE                           ICFGEN(QICFOP"JP",G0TOI,0);
    GOTO BRKRT; 
  
  
  
  
SPRC: 
      PROCITM = MEMR[LOPD[OOIX]];  #UNPACK SYMBOL TABLE POINTER TO NAME#
  
#     INITIALIZE SYMBOL TABLE FIELD DENOTING MULTIPLE ENTRY POINTS     #
  
    MUEN[PROCITM]=FALSE;
  
#     INITIALIZE SYMBOL TABLE FIELD DENOTING MULTIPLE FUNCTION RESULTS #
#     (A FUNCTION WITH ALTERNATE ENTRY POINTS )                        #
  
    MUFV[PROCITM]=FALSE;
      FUNCNUM = 0;           # INITIALIZE NO. OF FUNCTION RESULTS      #
      IADCON;                # INITIALIZATION FOR ADCON GENERATION     #
      TMPINT;                # INITIALIZATION FOR TEMP  GENERATION     #
  
#     IF THIS IS A FUNCTION WE ALLOCATE A TEMP FOR THE RESULT          #
#     NOTE WE ONLY ALLOCATE A TEMP IF IT HASN"T ALREADY BEEN DONE.     # NOV04
#     A TEMP WILL ALREADY HAVE BEEN ALLOCATED IF A NESTED PROC/FUNC    # NOV04
#     RETURNED A VALUE TO THE CURRENT FUNC NAME.                       # NOV04
  
    IF CLAS[PROCITM] EQ S"FUNC" THEN
         BEGIN
         FUNCNUM=1; 
         IF FVTP[PROCITM] EQ 0                                           NOV04
         THEN                                                            NOV04
           BEGIN                                                         NOV04
           FVTP[PROCITM] = TMPGEN(PLNG(PROCITM));                        NOV04
           END                                                           NOV04
         END
    ICFGEN(QICFOP"SPRC",PROCITM,0); 
    GOTO BRKRT; 
  
  
  
  
EPRC: 
  
#     IF WE HAVE JUST PROCESSED A FUNCTION WITH ALTERNATE ENTRY POINTS #
#     WE NOTE IT IN THE SYMBOL TABLE                                   #
  
    IF FUNCNUM GR 1 THEN MUFV[PROCITM]=TRUE;
    ICFGEN(QICFOP"EPRC",0,0); 
    GOTO BRKRT; 
  
  
  
  
RTRN: 
                                                                         SMPA044
#     IF THIS IS A PRGM, RETURN IS EQUIVALENT TO STOP.                 # SMPA044
                                                                         SMPA044
    IF PRGSW                                                             SMPA044
    THEN                                                                 SMPA044
      GOTO ST0P;                                                         SMPA044
    ICFGEN(QICFOP"RTRN",MEMR[LOPD[OOIX]],0);
    GOTO BRKRT; 
  
  
  
  
ENTR: 
  
#     CREATE A SYMBOL TABLE ENTRY OF CLAS "LABL" AND SET ENTRITN TO    #
#     POINT TO IT                                                      #
  
    ENTRITN=PLABL;
      ICFGEN(QICFOP"JP",ENTRITN,0);    # GENERATE JP AROUND PROLOG     #
  
#     PICK UP STMBOL TABLE POINTER TO PROC/FUNC CONTAINING THIS ENTRY  #
  
    ENTRITM=MEMR[LOPD[OOIX]]; 
      MUEN [PROCITM] = TRUE; # SET MULTIPLE ENTRY POINT FLAG           #
  
#     IF THIS ENTRY IS CONTAINED IN A FUNC WE ALLOCATE ANOTHER RESULT  #
#     TEMP                                                             #
  
    IF CLAS[ENTRITM] EQ S"FUNC" THEN
         BEGIN
          FUNCNUM = FUNCNUM + 1;       #BUMP COUNT OF ALTERNATE ENTRIES#
         FVTP[ENTRITM]=TMPGEN(PLNG(ENTRITM)); 
         END
    ICFGEN(QICFOP"ENTR",ENTRITM,0); 
    ICFGEN(QICFOP"LABL",ENTRITN,0); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
  
  
  
  
PROG: 
    PRGSW=TRUE;    #SETS FLAG FOR PTRM# 
  
#     UNPACK SYMBOL TABLE POINTER TO PROGRAM NAME                      #
  
    PROCITM=MEMR[LOPD[OOIX]]; 
  
#     INITIALIZE SYMBOL TABLE FIELD DENOTING MULTIPLE ENTRY POINTS     #
  
    MUEN[PROCITM]=FALSE;
  
#     INITIALIZE SYMBOL TABLE FIELD DENOTING MULTIPLE FUNCTION RESULTS #
#     (A FUNCTION WITH ALTERNATE ENTRY POINTS )                        #
  
    MUFV[PROCITM]=FALSE;
    ICFGEN(QICFOP"PRGM",PROCITM,0); 
  
      IADCON;                # INITIALIZATION FOR ADCON GENERATION     #
      TMPINT;                # INITIALIZATION FOR TEMP  GENERATION     #
  
      GOTO BRKRT; 
  
  
  
  
ST0P: 
          ICFGEN(QICFOP"SRV",PSICON(O"05160420000000000000"),6);
          ICFGEN(QICFOP"PCAL",PSCPRC("SYS="),0);
    GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
  
PCAL: #PROCEDURE CALL#
    PCALN=0; #TEMP RELEASE CHAIN HEAD#
    PCALO=0; #CLABEL LABEL, PARAMETER LIST GENERATED FLAG#
    PCALP=0; #PARAMETER VALUE TEMP, PARAMETER FLAG# 
    PCALI=MEMR[LOPD[OOIX]]; #PROC ENTRY#
    IGTNP;
    IF PCALL EQ 0 THEN
         BEGIN #NO PARAMETERS#
      IF B<59-"F">OPTION NQ 0 
          AND (XTRN[PCALI] EQ S"EXT" OR XTRN[PCALI] EQ S"WEAK") THEN
              BEGIN 
      SADCON;                                                            DON/D
      ADCON(0,0);                                                        DON/D
      PCALO = FADCON;                                                    DON/D
      END                                                                DON/D
      ICFGEN(QICFOP"PCAL",PCALI,PCALO);                                  DON/D
         GOTO BRKRT;
         END
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
SP00:    #AT LEAST ONE PARAMETER LEFT#
         IF OPTR[PCALJ] EQ QILOP"PRIM" THEN 
              BEGIN 
              PCALT=MEMR[PCALJ];
              #PASS SCALARS,TABLS,LABLS BY ADDRESS# 
              IF NOT SFLG[PCALJ] THEN 
                   BEGIN #UNSUBSCRIPTED#
SP05: 
          IF FPRI[MEMR[PCALJ]] EQ S"NAMC" OR BASD[PCALJ] THEN            DON/D
                        BEGIN #FORMAL PARAMETER AND/OR BASED ARRAY# 
                        BASD[PCALK]=T; #ADCON REPL FLAG#
                        INDX[PCALK]=PCALU; #ADCON LABL OFFSET#
                        END 
                   MEMR[PCALK]=PCALT; #ADCON OBJECT#
SP10:              GTNP;
                   IF PCALL NQ 0 THEN GOTO SP00;
                   GOTO SP20; #NO MORE PARAMETERS#
                   END #NOT SFLG# 
  
          ELSE
  
          IF CLAS[MEMR[PCALJ]] EQ S"TABL" THEN
  
            BEGIN 
            MEMR[PCALK] = PCALT;
            IF FPRI[MEMR[PCALJ]] EQ S"NAMC" 
            OR BASD[PCALJ] THEN 
                # MUST GENERATE DYNAMIC ACTUAL FOR BASED OR FORMAL  # 
              BEGIN 
              ICFGEN( QICFOP"OFFS" , MEMR[PCALJ] , OFFS[PCALJ] ); 
              GOTO SP15;
              END 
  
               # STATIC ARRAY WITH CONSTANT SUBSCRIPT     # 
            OFFS [PCALK] = OFFS[PCALJ]; 
            GOTO SP10;
  
            END 
              IF OFFS[PCALJ] EQ 0 AND CLAS[MEMR[PCALJ]] EQ S"ARRY" THEN 
                   BEGIN #AMBIGUOUS TRIAD PASSED BY ADDRESS#
                   GOTO SP05; 
                   END
              END #OPTR EQ PRIM#
  
         IF OPTR[PCALJ] EQ QILOP"SUBS"
         AND CLAS[MEMR[LOPD[PCALJ]]] EQ QCLAS"TABL" THEN
  
         #  CHECK FOR SUBCRIPTED ARRAY NAMES      # 
  
           BEGIN         # SUBSCRIPTED ARRAY NAME   # 
          EXPGEN ( ROPD[PCALJ]);    # GENERATE SUBSCRIPT  # 
            INDX[LOPD[PCALJ]] = MEMR[ROPD[PCALJ]];
            SLOD ( LOPD[PCALJ]);    # GENERATE OFFS/SUBS       #
          MEMR[PCALK] = MEMR[LOPD[PCALJ]] ; 
SP15: 
  
                 # MUST CALCULATE ADDRESS DYNAMICALLY    #
  
            BASD[PCALJ] = T;
            BASD[PCALK] = T;
            INDX[PCALK] = PCALU;
            MEMR[PCALK] = ICFPTR; 
  
          GOTO SP10;
  
          END 
  
         #PASS BY VALUE#
         KLSS[PCALJ] = S"SOURCE"; 
         EXPGEN(PCALJ); 
      IF AC$S[PCALJ] EQ S"GR" THEN BEGIN #STORE STRING IN TEMP# 
          SAVESV(NXOP[PCALJ]);                 #SAVE INFO IS IN PLST   #
          PCALP=KCT00(PCALJ); 
          TPCH[PCALP]=PCALN;
          PCALN=PCALP;
          MEMR[PCALK]=PCALP;
         GOTO SP10; 
          END 
         PCALT=MEMR[PCALJ]; 
         IF PCALT LS 0 THEN 
              BEGIN #ICF COMPUTATION# 
              PCALP=TMPGEN(1);
              TPCH[PCALP]=PCALN;
              PCALN=PCALP;
              ICFGEN(QICFOP"REPL",PCALP,PCALT); #GENERAL REPL#
              MEMR[PCALK]=PCALP;
              END 
         #MUST BE 0-INDEXED NON-BASED FULLWORD ITEM,TEMP, OR BASED PTR# 
         ELSE MEMR[PCALK]=PCALT;
         GOTO SP10; 
SP20:     #ALL PARAMETERS NOW PROCESSED:  
         MEMR OF PCAL-PLST CONTAINS ADCON OBJECT SYMBOL TABLE POINTER,
         INDX OF PCAL-PLST CONTAINS ADCON LABEL OFFSET, 
         BASD OF PCAL-PLST IS TRUE IF ADCON STORE,
         PCALN HEADS THE LIST OF ALL TEMPS TO BE RELEASED AFTER PCAL# 
         #NOW GENERATE ADCONS#
         IGTNP; 
         SADCON;
SP25:    #AT LEAST ONE PARAMETER LEFT#
         PCALT=MEMR[PCALK]; #ADCON OBJECT#
         IF BASD[PCALK] THEN
              BEGIN #NON-CONSTANT ADDRESS BEING PASSED# 
  
              IF PCALT LS 0 THEN
                BEGIN     # SUBSCRIPTED ARRAY NAME   #
                ICFGEN ( QICFOP"LOC" , PCALT , 0 ); 
                MEMR[PCALK] = ICFPTR; 
                PCALT = MEMR[PCALJ];
                END 
  
              ELSE
  
              IF NOT(CLAS[PCALT] EQ QCLAS"TABL" AND BASD[PCALJ]) THEN 
                   BEGIN #NOT A BASED ARRAY#
                   ICFGEN(QICFOP"LOC",PCALT,0); 
                   MEMR[PCALK]=ICFPTR;
                   END
              ELSE
                   BEGIN  #BASED ARRAY# 
                   PCALV = PCALT; 
                   IF  OPTR[PCALJ] EQ S"FUNI" THEN    #ASSUME PFUN     #
                        BEGIN  #PARM BA#
                        ICFGEN(QICFOP"PFUN",PCALV,0); 
                        PCALV = ICFPTR; 
                        END  #PARM BA#
                   ICFGEN(QICFOP"LOC",PCALV,0); 
                   MEMR[PCALK] = ICFPTR;
                   END
              ADCON(PCALT,1); 
              END 
  
            ELSE
  
              IF OFFS[PCALK] NQ 0 THEN
                   # STATIC ARRAY WITH CONSTANT OFFS  # 
                ADCNO ( MEMR[PCALK] , OFFS[PCALK] , 0 );
  
         ELSE ADCON(PCALT,0); 
         GTNP;
         IF PCALL NQ 0 THEN GOTO SP25;
                                                                         DON/D
                                                                         DON/D
#     IF F-OPTION SELECTED (FORTRAN COMPATABLE CALLING SEQUENCE) PUT   # DON/D
#     OUT A ZERO TO TERMINATE APLIST.                                  # DON/D
                                                                         DON/D
      IF (B<59-"F">OPTION NQ 0                                           DON/D
          AND (XTRN[PCALI] EQ S"EXT" OR XTRN[PCALI] EQ S"WEAK"))
      THEN ADCON(0,0);
         IGTNP; 
         PCALO=FADCON;
         FOR PCALO=PCALO  WHILE PCALL NQ 0 DO 
              BEGIN #AT LEAST ONE PARAMETER LEFT# 
              IF BASD[PCALK] THEN 
                   BEGIN
                   ICFGEN(QICFOP"OFFS",PCALO,INDX[PCALK]);
                   ICFGEN(QICFOP"REPL",ICFPTR,MEMR[PCALK]); 
                   END
              GTNP; 
              END 
         ICFGEN(QICFOP"PCAL",PCALI,PCALO);
SP35:    #RELEASE ANY TEMPS#
         IF PCALN NQ 0 THEN 
              BEGIN 
              PCALP=PCALN;
              PCALN=TPCH[PCALN];
              TMPRLS(PCALP);
              GOTO SP35;
              END 
         GOTO BRKRT;
  
                                                                         DON/D
                                                                         DON/D
  
FRES: #FUNCTION RESULT# 
#     IF WE ARE SETTING A FUNC WHICH CONTAINS THIS PROC/FUNC, THEN     # NOV04
#     A TEMP HASN"T BEEN ALLOCATED FOR IT YET (DONE FOR SPRC OPERATOR) # NOV04
#     SO WE MUST ALLOCATE ONE.                                         # NOV04
                                                                         NOV04
    IF FVTP[MEMR[LOPD[OOIX]]] EQ 0                                       NOV04
    THEN                                                                 NOV04
      BEGIN                                                              NOV04
      FVTP[MEMR[LOPD[OOIX]]] = TMPGEN(PLNG(MEMR[LOPD[OOIX]]));           NOV04
      END                                                                NOV04
    MEMR[LOPD[OOIX]]=FVTP[MEMR[LOPD[OOIX]]];
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
REPL: #REPLACE OPERATOR#
              REPRC;                                                     JANDRE 
    GOTO BRKRT; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
DEADS:  #PASS 1 TEMP IS NOW DEAD    # 
        MYNE = MEMR [LOPD [OOIX] ]   ;
        IF MYNE EQ -1 THEN GOTO  BRKRT; 
                         #THIS IS A SHORT TEMP# 
        ICFGEN (QICFOP"DEAD" , ICFS[MYNE] , MYNE ); 
        TMPRLS (MYNE)  ;
        GOTO BRKRT ;
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
SLOP: #START LOOP#
    FLSCPX=FLSCPX+1;
    IF FLSCPX GR 26                                                      BRKPT
    THEN                                                                 BRKPT
      BEGIN                                                              BRKPT
      SYMABTL(J837,"LOOP STACK OVERFLOW(BRKPT) LINE XXXXX",37,LINUM);    BRKPT
      END                                                                BRKPT
    SLOPI=MEMR[LOPD[OOIX]]; 
    FLSCPL[FLSCPX]=SLOPI; #STACK LABEL# 
    ICFGEN(QICFOP"LABL",SLOPI,0); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    GOTO BRKRT; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
ENDX: #END LOOP#
    IF SLOPI EQ FLSCPL[FLSCPX] THEN 
         BEGIN #INNER-MOST LOOP#
         LBIL[SLOPI]=TRUE;
         END
    FLSCPX=FLSCPX-1;
    IF FLSCPX LS 0                                                       BRKPT
    THEN                                                                 BRKPT
      BEGIN                                                              BRKPT
      SYMABTL(J838,"LOOP STACK UNDERFLOW(BRKPT) LINE XXXXX",38,LINUM);   BRKPT
      END                                                                BRKPT
    GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
INVI: #INDUCTION VARIABLE INITIALIZATION# 
    EXPGEN(ROPD[OOIX]); 
    ICFGEN(QICFOP"INVI",MEMR[LOPD[OOIX]],MEMR[ROPD[OOIX]]); 
    GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
INSP: 
INSM: 
INSD: 
    INVF1=MEMR[LOPD[OOIX]]; #INDUCTION VARIABLE#
    INVF2=OPTR[OOIX]- QILOP"INSP"; #0=INSP, 1=INSM, 2=INSD# 
    EXPGEN(ROPD[OOIX]); 
    INVTI=MEMR[ROPD[OOIX]]; #STEP EXPRESSION# 
            ICFGEN ( QICFOP"INVS" , INVF1 , ICFS[INVTI]) ;
                             #2ND OP. IS SAVE OF STEP   # 
    IF INVF2 EQ 2 #DYNAMIC TEST# THEN 
         BEGIN
         ICFGEN(QICFOP"SAVE",0,INVTI); #POSSIBLE TEST FCAL# 
         STEX[INVF1]=ICFPTR;
         END
    TDRC[INVF1]=INVF2;
    GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
INVT: #INDUCTION VARIABLE TEST# 
    EXPGEN(ROPD[OOIX]); 
    INVTI=MEMR[LOPD[OOIX]]; 
    INVTJ=MEMR[ROPD[OOIX]]; 
    IF INVTI EQ INVTJ THEN
         BEGIN #2-FACTOR# 
         ICFGEN(QICFOP"JP",FLSCPL[FLSCPX],0); 
         GOTO BRKRT;
         END
        INVTJ = ICFS [INVTJ];   #POINT TO SAVE OF LIMIT   # 
    INVF2=TDRC[INVTI];
    IF INVF2 NQ 2 THEN
         BEGIN #NOT DYNAMIC TEST# 
         IF INVF2 NQ 0 THEN 
              BEGIN #SWAP#
              INVF1=INVTI;
              INVTI=INVTJ;
              INVTJ=INVF1;
              END 
         ICFGEN(QICFOP"INVT",INVTJ,INVTI);
         ICFGEN(QICFOP"INVB",FLSCPL[FLSCPX],ICFPTR);
         GOTO BRKRT;
         END
    #DYNAMIC TEST#
    INVF2=STEX[INVTI];
    ICFGEN(QICFOP"ISUB",INVTI,INVTJ); 
    ICFGNR(QICFOP"SAVE",0,-1);
    ICFGEN(QICFOP"LEQV",ICFPTR,INVF2);
    ICFGNR(QICFOP"SAVE",0,-1);
    INVF1=FLSCPL[FLSCPX]; 
    LREF[INVF1]=LREF[INVF1]+1;
    ICFGNR(QICFOP"PL",INVF1,-1);
    ICFGNR(QICFOP"ZR",INVF1,-4);
    ICFGNR(QICFOP"DEAD",-5,0);
    ICFGNR(QICFOP"DEAD",-4,0);
    ICFGEN(QICFOP"DEAD",INVF2,0); 
    GOTO BRKRT; 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
VALD:       #  VALU DEFINITION.   PRETEND ITS A VALB.  #
    OPTR   [OOIX] = QILOP "VALB"; 
    EXPGEN (OOIX);
    GOTO   BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
PTRM: #PROGRAM TERMINATOR#
    IF PRGSW THEN 
         BEGIN #MAIN PROGRAM-GENERATE STOP CODE#
          ICFGEN(QICFOP"SRV",PSICON(O"05160420000000000000"),6);
          ICFGEN(QICFOP"PCAL",PSCPRC("SYS="),0);
         END
    ICFGEN(QICFOP"PTRM",0,0); 
    GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
SWCH: #SWITCH DECLARATION#
      SWCHNM=MEMR[LOPD[OOIX]];
         NOSP=0;
      IF OPTIONA THEN 
          BEGIN 
               SWCHNM$=PLABL; 
              BINDEC(WHERE$,5,LINUM,4); 
              SWCHLB=CLABL;#CODE FILE LABEL FOR JUMP VECTOR#
          END 
                 ELSE   #TEST IF SWITCH IS REFENENCED VIA XDEF#          NEWFEAT
                     IF XTRN[SWCHNM] EQ QXTRN"ENT" THEN                  NEWFEAT
                                                   SWCHLB = CLABL;       NEWFEAT
                        #GENERATE AN INTERNAL LABEL FOR JUMP VECTOR#     NEWFEAT
      ELSE  # PUT SWITCH NAME ON JUMP VECTOR# 
      BEGIN 
              ASEQ[LENT[CSLC]]=SWCHNM;
              LOCN[SWCHNM]=SSIZ[CSLC];
               LENT[CSLC]=SWCHNM; 
              CF00[CFIX]=0; 
              CFOP[CFIX]=QCFOP"LABL"; 
              CFST[CFIX]=SWCHNM;
              CODE; 
          END 
      GOTO BRKRT; 
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
ENDS: #END SWITCH DECLARATION#
          FJPINS(0);
      IF OPTIONA THEN                                                    DON/D
          BEGIN              #RANGE CHECKING#                            DON/D
          ICFGEN(QICFOP"LABL",SWCHNM$,0);                                DON/D
          ICFGEN(QICFOP"SRV",PSICON(WHERE$),5);                          DON/D
          ICFGEN(QICFOP"PCAL",PSCPRC("SYMBSW$"),0);                      DON/D
    ICFGEN(QICFOP"LABL",SWCHNM,0); #SWITCH ENTRY POINT# 
          ICFGEN(QICFOP"DRV",0,XREG1);    #SWITCH INDEX VALUE#
         ICFGNR(QICFOP"SAVE",0,-1); 
         SWCHI = ICFPTR;
              SWCHJ = SWCHI;  # LOW BOUNDS VALUE #
      ICFGEN(QICFOP"NG",SWCHNM$,SWCHJ);          #LO BOUNDS TEST#        DON/D
         ICFGEN(QICFOP"ISUB",SWCHI,PSICON(NOSP)); 
          ICFGNR(QICFOP"PL",SWCHNM$,-1);       #HI BOUNDS TEST# 
              IF OPTIONB THEN 
                   BEGIN  # SWITCH POINTS PACKED TWO PER WORD # 
                   ICFGEN(QICFOP"LSHC",SWCHI,59); 
                   ICFGEN(QICFOP"DEAD",SWCHI,0);
                   ICFGNR(QICFOP"SRV",-2,1);
                   SWCHN = ICFPTR;
                   ICFGEN(QICFOP"IJP",SWCHLB,SWCHN);
                   GOTO BRKRT;
                   END  # SWITCH POINTS PACKED TWO PER WORD # 
      ICFGEN(QICFOP"OFFS",SWCHLB,NOSP); 
         ICFGEN(QICFOP"ADSC",SWCHI,PSICON(-NOSP));
         ICFGNR(QICFOP"IJP",-2,-1); 
         ICFGEN(QICFOP"DEAD",SWCHI,0);
          END 
   ELSE   # TRST IF SWITCH REFERENCED FROM OUTSIDE (I.E. VIA XDEF)  #    NEWFEAT
       IF XTRN[SWCHNM] EQ QXTRN"ENT" THEN                                NEWFEAT
          BEGIN   #MAKE A JUMP ROUND LABEL#                              NEWFEAT
      SWIGNL = PLABL;        # GOTO JUMP AROUND LABEL                  #
              ICFGEN(QICFOP"JP",SWIGNL,0) ;                              NEWFEAT
              ICFGEN(QICFOP"LABL",SWCHNM,0); #SWITCH ENTRY POINT#        NEWFEAT
              ICFGEN(QICFOP"DRV",0,XREG1);      #INDEX INTO X1# 
              SWCHI = ICFPTR;                                            NEWFEAT
              IF OPTIONB THEN     #PACKED SWITCHES#                      NEWFEAT
              BEGIN                                                      NEWFEAT
                    ICFGEN(QICFOP"LSHC",SWCHI,59) ;   #HALF INDEX#       NEWFEAT
                    SWCHN = ICFPTR;                                      NEWFEAT
                    ICFGEN(QICFOP"SRV",SWCHN,1);  #ENSURE X1 ODD/EVEN#   NEWFEAT
                    SWCHI = ICFPTR;                                      NEWFEAT
               END                                                       NEWFEAT
               ICFGEN(QICFOP"IJP" ,SWCHLB,SWCHI) ; #JUMP TO VECTOR#      NEWFEAT
               ICFGEN(QICFOP"LABL",SWIGNL,0) ;  #JUMP ROUND LABEL#       NEWFEAT
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
          END  #XDEF SWITCH#                                             NEWFEAT
         GOTO BRKRT;
  
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
SWPT: #SWITCH POINT REFERENCES LOCAL LABEL OR NULL# 
    SWCHJ=MEMR[LOPD[OOIX]]; #NEW SWITCH POINT#
SX00: 
    NOSP=NOSP+1;
    IF NOSP EQ 0 THEN GOTO L01; 
          JPINS(SWCHJ); 
          GOTO BRKRT; 
L01:                                                                     BRKPT
    SYMABTL(J833,"BAD SWITCH STATE INDEX(BRKPT) LINE XXXXX",40,LINUM);   BRKPT
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
GSWP: #GENERATED SWITCH POINT REFERENCING PARAMETER LABEL/SWITCH/CLOSE# 
          IF CLAS[MEMR[LOPD[OOIX]]] EQ S"LABL" THEN 
            BEGIN 
              ITEM ISWCHK;
              ISWCHK = PLABL;    #GENERATE BY-PASS LABEL# 
              ICFGEN (QICFOP"JP" ,ISWCHK,0);
            END 
    SWCHJ=PLABL; #NEW SWITCH POINT# 
    ICFGEN(QICFOP"LABL",SWCHJ,0); 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
    SWCHK=MEMR[LOPD[OOIX]]; 
    IF CLAS[SWCHK] EQ S"LABL" THEN
         BEGIN
         ICFGEN(QICFOP"RTRN",SWCHK,0);
                 ICFGEN( QICFOP"LABL" , ISWCHK , 0 );  #BY-PASS TOHERE# 
      PNOTT;                 #GENERATE POINTS-NOT-TESTED INTERFACE CODE# DON/D
         END
    GOTO SX00;
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
SSWC: #SUBSCRIPTED SWITCH CALL# 
    SWCHI=MEMR[LOPD[OOIX]]; 
    EXPGEN(ROPD[OOIX]); 
      SWCHX = XTRN[ SWCHI] ;                                             NEWFEAT
      IF OPTIONA OR (SWCHX EQ QXTRN"EXT") OR (SWCHX EQ QXTRN"ENT")       NEWFEAT
          OR (SWCHX EQ QXTRN"WEAK") 
               THEN                                                      NEWFEAT
      BEGIN    # WE KNOW THAT THE SWITCH BODY IS INTELLIGENT#            NEWFEAT
    ICFGEN(QICFOP"SRV",MEMR[ROPD[OOIX]],1); 
      ICFGEN(QICFOP"JP",SWCHI,0); 
    GOTO BRKRT; 
      END 
      ELSE
      BEGIN 
          SWCHJ=MEMR[ROPD[OOIX]]; 
          IF OPTIONB THEN 
              BEGIN 
              ICFGEN(QICFOP"SRV",SWCHJ,1);
              SWCHN=ICFPTR; 
              ICFGEN(QICFOP"LSHC",SWCHN,59);
              SWCHN=ICFPTR; 
              ICFGEN(QICFOP"IJP",SWCHI,SWCHN);
              END 
          ELSE
              ICFGEN(QICFOP"IJP",SWCHI,SWCHJ);
      END 
       GOTO BRKRT;
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
JOVY: #JOVIAL ONLY#                                                      JANDRE 
      SYMABTL(J840,"ILLEGAL IL OP VALUE(BRKPT) LINE XXXXX",37,LINUM);    BRKPT
                                                                         DON/D
                                                                         DON/D
  
PAUS: #LINE NUMBER# 
    LINUM=MEMR[OOIX]; 
    IF OPCD[ICIX-1] NQ QICFOP"LINE" THEN                                 JANDRE 
         BEGIN
         ICFGEN(QICFOP"LINE",LINUM,0);
         IF CIDDB NQ 0 THEN       # CID DEBUG OPTION SET  #              JUNK 
            BEGIN                                                        JUNK 
            ICFGEN (QICFOP"PCAL" , PSCPRC("DBUG.LN") , 0);               JUNK 
            END                                                          JUNK 
         END
         ELSE OPN1[ICIX-1]=LINUM;                                        JANDRE 
                                                                         DON/D
                                                                         DON/D
                                                                         DON/D
  
SWAP: 
BRKRT:  
    IF DVSPI NQ DVSP THEN 
         BEGIN #PURGE DEAD VALUS# 
         DVSPJ=SICF[DVSP];
         IF DVSPJ LS 0 THEN 
              BEGIN #LOCALLY SAVED VALUE# 
              ICFGEN(QICFOP"DEAD",DVSPJ,0); 
              DVSP=SNXT[DVSP];
              GOTO BRKRT; 
              END 
         END
END 
TERM
