*DECK             ADCON 
USETEXT   TSOURCE 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TCEXEC
# ADCON -- ADDS A NEW ADCON TO PARAMETER LIST BEING BUILT.             #
#                                                                      #
PROC ADCON((ST),(SI));
BEGIN 
  
  
  
*CALL COMEX 
  
  
  
    ITEM ST;             # S.T. INDEX OF ENTRY FOR WHICH ADCON IS BUILT#
    ITEM SI;             # NON-ZERO IF STORED INTO                     #
    ITEM SD;             # LOCAL VALUE OF STO # 
    ITEM SP=0;           # STACK POINTER #
    ITEM SX;             # CURRENT CST INDEX #
    ITEM I,J,K,L,M; 
  
      $BEGIN
      DEF ADCONDBUG  #B<15>INTOPS NQ 0#;
      $END
  
    DEF SPLD  #49#;           # NUMBER WORDS-1 IN PARAM. LIST DICT.    #
    DEF J844 #844#;                # SYMABT DIAGNOSTIC 844             # ADCON
    DEF J845 #845#;                # SYMABT DIAGNOSTIC 845             # ADCON
    DEF J846 #846#;                # SYMABT DIAGNOSTIC 846             # ADCON
    DEF J847 #847#;                # SYMABT DIAGNOSTIC 847             # ADCON
    ARRAY  [0:SPLD] S(1);     # PARAMETER LIST DICTIONARY              #
    ITEM PLE I (0,0,18),      # LAST ADCON IN PARAMETER LIST S.T. INDEX#
         NP  I (0,42,18),     # NUMBER OF ADCONS IN PARAMETER LIST     #
         PLSCP I(0,24,18),    # PARAMETER LIST SCOPE                   #
         PLSTR U(0,18,6);     # NON-ZERO IF ADCON STORED INTO          #
    ITEM SCOPE I = 0; 
    ITEM STORE U = 0;         # NON-ZERO IF A STORE INTO PARAMETER LIST#
    ARRAY  [0:49] S(1);       # CURRENT PARAMETER LIST DESCRIPTION     #
    ITEM CST   I(0,0,18),     # S.T. ENTRY WHICH ADCON DESCRIBES       #
         CSTOFF I(0,18,18),   # OFFSET OF ADCON OBJECT                 #
         CSTORE B(0,42,1);    # =T IF ADCON STORED INTO # 
    ITEM NPLD I=0;       # NUMBER OF PARAMETER LIST DICTIONARY ENTRIES #
    ITEM XPLD I=0;       # STORE INDEX OF NEXT PLD ENTRY               #
    ARRAY [1:35] S(1); # STACK #
    ITEM CSTI U (0,0,6), # CURRENT PARAMETER LIST LENGTH #
         CSTS U (0,6,1), # 1=CURRENT PARM LIST STORED-INTO# 
         CSTX I (0,42,18), # CURRENT PARM LIST STARTING INDEX # 
         CST0 I (0,0,60); # FULL-WORD OVERLAY # 
    XREF PROC CALOC;
    XREF PROC POST; 
    XDEF PROC IADCON; 
    XREF PROC SYMABT;                                                    ADCON
    XDEF PROC SADCON; 
    XDEF FUNC FADCON; 
    SD=0; 
    GOTO AD00;
ENTRY PROC ADCNO((ST),(STO),(SI));
    ITEM STO;                 # OFFSET OF ENTRY                        #
    SD=STO; 
CONTROL EJECT;
PROC SADCON;  # INITIALIZE NEXT PARAMETER LIST ENTRY                   #
BEGIN 
    SP=SP+1;
    IF SP GR 35                                                          ADCON
    THEN                                                                 ADCON
      BEGIN                                                              ADCON
      SYMABT(J845,"PARM STACK OVERFLOW(SADCON IN ADCON)",36);            ADCON
      END                                                                ADCON
    CST0[SP]=0; #CLEARS CSTI,CSTS,CSTX# 
    CSTX[SP]=SX;
END # SADCON #
CONTROL EJECT;
PROC IADCON;       # CALLED WHEN SCOPE CHANGES                         #
BEGIN 
    IF SP NQ 0                                                           ADCON
    THEN                                                                 ADCON
      BEGIN                                                              ADCON
      SYMABT(-J844,"PARM STACK NON-EMPTY(IADCON IN ADCON)",37);          ADCON
      END                                                                ADCON
    SP=0; SX=0; 
    SCOPE = SCOPE+1;
END # IADCON #
CONTROL EJECT;
# FADCON -- CALLED AFTER LAST ADCON CALL TO BUILD THE PARAMETER LIST.  #
#           VALUE IS THE S.T. INDEX OF 1ST ADCON IN LIST.              #
CONTROL EJECT;
FUNC FADCON;
BEGIN 
# EXAMINE ALL KNOWN PARAMETER LISTS TO FIND ONE THAT MATCHES THE       #
# CURRENT ONE.                                                         #
#                                                                      #
    I=CSTI[SP]; 
    STORE=CSTS[SP]; 
$BEGIN
      IF  ADCONDBUG 
      THEN
         BEGIN
         PRINT("(7H0SCOPE=I2,7H STORE=I1,6H NPLD=I2,6H XPLD=I2,3H I=I2)"
);
         LIST(SCOPE); 
         LIST(STORE); 
         LIST(NPLD);
         LIST(XPLD);
         LIST(I); 
         ENDL;
         PRINT("(5H PLE=O6,4H NP=I2,7H PLSCP=I2,7H PLSTR=I1/)");
         ITEM M;
         GOTO OUF;   # BYPASS VERY LONG OUTPUT #                         JANDRE 
         FOR M=NPLD-1 STEP -1 UNTIL 0 DO
              BEGIN 
              LIST(PLE[M]); 
              LIST(NP[M]);
              LIST(PLSCP[M]); 
              LIST(PLSTR[M]); 
              END 
         ENDL;
         OUF:                                                            JANDRE 
         END
$END
    FOR J = NPLD-1 STEP -1 UNTIL 0 DO 
    BEGIN 
        IF NP[J] GQ I THEN
        BEGIN  # THE  JTH LIST HAS AS MANY PARAMS AS THE CURRENT LIST  #
        # DONT USE THIS LIST IF -                                      #
        #  1. THE CURRENT LIST IS STORED INTO AND THIS ONE IS NOT.     #
        #     OR                                                       #
        #  2. BOTH LISTS ARE STORED INTO BUT ARE AT DIFFERENT SCOPES   #
        #                                                              #
            IF STORE NQ 0 THEN
                IF PLSTR[J] EQ 0 OR SCOPE NQ PLSCP[J] THEN GOTO FDC10;
            L = PLE[J];  # LAST ADCON IN PARAMETER LIST                #
        # COMPARE ALL ADCONS IN THE TWO LISTS, STARTING AT THE END OF  #
        # EACH LIST.                                                   #
            FOR M=I-1 STEP -1 UNTIL 0 DO
            BEGIN 
                K=M+CSTX[SP]; 
                IF (CST[K] EQ ALNK[L] AND CSTOFF[K] EQ DSPL[L] AND
                   NOT CSTORE[K] AND NOT DBCT[L]) OR
                   CSTORE[K] AND DBCT[L] THEN 
                BEGIN #THIS ADCON MATCHES, CHECK PRECEDING ONE# 
                    FADCON=L; 
                    L=NLNK[L];
                    TEST M; 
                END 
                TEST J; 
            END 
        # ALL ADCONS MATCH, USE THIS LIST                              #
            SX=CSTX[SP];
            SP=SP-1;
            IF SP LS 0                                                   ADCON
            THEN                                                         ADCON
              BEGIN                                                      ADCON
FDC8:                                                                    ADCON
              SYMABT(J846,"PARM STACK UNDERFLOW(FADCON IN ADCON",37);    ADCON
              END                                                        ADCON
            RETURN; 
        END 
FDC10:  # LISTS DONT MATCH, LOOK AT NEXT LIST                          #
    END 
# NO LISTS MATCH, ENTER NEW PARAMETER LIST                             #
#                                                                      #
    K = 0;
    FOR M=1 STEP 1 UNTIL I DO 
    BEGIN 
        J=M+CSTX[SP]; 
        POST(NONAM,ADCN$W,L); 
        CLAS[L] = S"ADCN";
        POSI[L] = QPOSI"LOWER"; 
        ASEQ[LENT[APLC]] = L; 
        LENT[APLC] = L; 
        LOCN[L] = SSIZ[APLC]; 
        SSIZ[APLC] = SSIZ[APLC]+1;
        NLNK[L] = K; # LINK LIST BACKWORDS USING  NLNK.                #
        K = L;
        ALNK[L] = CST[J-1]; 
        DSPL[L]=CSTOFF[J-1];
        IF CSTORE[J-1] THEN DBCT[L] = TRUE; 
        IF M EQ 1 THEN FADCON=L;
    END 
    PLSCP[XPLD] = SCOPE;
    PLSTR[XPLD] = STORE;
    PLE[XPLD] = K;  # LAST ADCON IN LIST                               #
    NP[XPLD] = I;   # NUMBER OF ADCONS IN LIST                         #
    XPLD = XPLD+1;  # NEXT INDEX TO SAVE PARAMETER LIST                #
    IF XPLD GR NPLD THEN NPLD = XPLD; 
    IF XPLD GR SPLD THEN XPLD = 0; # IF END OF SAVE TABLE, START AT 0  #
    SX=CSTX[SP];
    SP=SP-1;
    IF SP LS 0                                                           ADCON
    THEN                                                                 ADCON
      BEGIN                                                              ADCON
      GOTO FDC8;                                                         ADCON
      END                                                                ADCON
END # FADCON #
CONTROL EJECT;
# ENTER ADCON IN CURRENT PARAMETER LIST DESCRIPTION                    #
#                                                                      #
AD00: 
    I=SX; 
    CSTOFF[I]=SD; 
    CST[I] = ST;
    CSTORE[I]=FALSE;
    IF SI NQ 0 THEN 
         BEGIN
         CSTORE[I]=TRUE;
         CSTS[SP]=1;
         END
##       $BEGIN 
      IF ADCONDBUG
      THEN
         BEGIN
         PRINT("(6H0ALNK=O6,6H DSPL=O6,4H SI=I1,3H I=I2)"); 
         LIST(CST[I]);
         LIST(CSTOFF[I]); 
         LIST(CSTORE[I]); 
         LIST(I); 
         ENDL;
         END
##       $END 
    CSTI[SP]=CSTI[SP]+1;
    SX=I+1; 
    IF SX GR 49                                                          ADCON
    THEN                                                                 ADCON
      BEGIN                                                              ADCON
      SYMABT(J847,"PARAM LIST OVERFLOW(ADCON)",26);                      ADCON
      END                                                                ADCON
    IF CLAS[ST] EQ S"CONS" THEN CALOC(ST);
END  # ADCON #
TERM
