*DECK PATHC 
USETEXT COMCBEG 
USETEXT COMRDSD 
USETEXT COMRNET 
PROC PATHC; 
# TITLE PATHC - PROCESS PATH COMMAND #
  
      BEGIN  # PATHC #
  
# 
**    PATHC - PROCESS PATH COMMAND
* 
*     DO PROCESSING A S SPECIFIED BY THE PATH COMMAND 
* 
*     PROC PATHC
* 
*     ENTRY      - DSD$BUF CONTAINS PATH COMMAND
* 
*     EXIT       - PATH UPDATED OR ERROR DISPLAYED
* 
*     PROCESSING -
*         FIND PATH ASSOCIATED WITH ORD 
*         IF VALID PATH NOT FOUND 
*         THEN
*           CALL ERROR
*         ELSE
*           ASLONGAS (NOT END OF COMMAND AND NOT CMDERR) DO 
*           CALL GETPAR(PARA) 
*           IF PARAMETER NOT VALID
*           THEN
*             CMDERR=TRUE 
*           ELSE
*             FIND FORMAL PARAMETER ORD 
*             IF NOT A VALID FORMAL PARAMETER 
*             THEN
*               CMDERR=TRUE 
*             ELSE
*               CASE(FORMAL PAR ORD,AC) PROCESS AC COMMAND
*               CASE(FORMAN PAR ORD,DD) PROCESS DD COMMAND
*               CASE(FORMAL PAR ORD,LT) PROCESS LT COMMAND
*               CASE(FORMAL PAR ORD,ND) PROCESS ND COMMAND
*               CASE(FORMAL PAR ORD,RT) PROCESS RT COMMAND
*               CASE(FORMAL PAR ORD,LOG) PROCESS LOG COMMAND
*           IF COUNT(LTBITS) NE COUNT(RTBITS) 
*           THEN
*             CMDERR=TRUE 
*           IF CMDERR 
*           THEN
*             CALL ERROR
*           ELSE
*             UPDATE PATH 
*         RETURN
# 
  
# 
****  PROC PATHC XREF LIST BEGIN
# 
      XREF
        BEGIN 
        FUNC BDTOBIN I; 
        FUNC HDTOBIN I; 
        PROC ERROR; 
        PROC GETPAR;
        ITEM NDTADDR  I;             # NETWORK DEFINITION TABLE ADDR #
        END 
# 
****  PROC PATHC XREF LIST END. 
# 
  
  
      ARRAY BITS [0:0] S(1);
        BEGIN 
        ITEM BIT$LT     U(00,00,04); # LOCAL TRUNK ENABLES TEMPORARIES #
        ITEM BIT$RT     U(00,56,04); # REMOTE TRUNK ENABLES TEMPORARIES#
        END 
  
      ARRAY FORPAR [1:MAXFORPSZ] S(1);
        BEGIN 
        ITEM FORP       U(00,00,60); # REFERENCE ENTIRE WORD #
        ITEM FORC       C(00,00,07) = ["AC",
                                       "DD",
                                       "LT",
                                       "ND",
                                       "RT",
                                       "LOG"];
        ITEM FORMAXL    I(00,55,05) = [ MAXAC,
                                        MAXDD,
                                        MAXLT,
                                        MAXND,
                                        MAXRT,
                                        MAXLOG];
        END 
  
      ARRAY PAR [0:0] S(2); 
        BEGIN 
        ITEM PAR$FORP   C(00,00,07); # FORMAL PARAMETER # 
        ITEM PAR$EOC    B(00,54,01); # END OF COMMAND FLAG #
        ITEM PAR$PARLEN I(00,55,05); # ACTUAL PARMETER LENGTH # 
        ITEM PAR$PAR    C(01,00,07); # ACTUAL PARAMETER # 
        ITEM PAR$WD1    U(01,00,60); # REFERENCE WORD 1 # 
        END 
  
      ITEM  ACCODE U; 
      ITEM  CMDERR B; 
      ITEM  DESTIN U; 
      ITEM  DONE B; 
      ITEM  FOUND B;
      ITEM  I I;
      ITEM  LOGBIT B; 
      ITEM  LTCNT U;
      ITEM  NDCODE U; 
      ITEM  RTCNT U;
  
      SWITCH CASEFORP 
                      , 
                      AC, 
                      DD, 
                      LTLAB,
                      ND, 
                      RT, 
                      LOG,
                      ; 
CONTROL EJECT;
  
      P<NET$HEADER> = NDTADDR;
      CMDERR = FALSE; 
      DONE = FALSE; 
      PAR$EOC[0] = FALSE; 
      I = 0;
      ASLONGAS NOT DONE DO
        BEGIN 
        IF PATHORD GR (I + NET$NMPATH[0]) 
        THEN
          BEGIN 
          IF NET$NXTPID[0] EQ 0 
          THEN
            BEGIN 
            DONE = TRUE;
            END 
          ELSE
            BEGIN 
            I = I + NET$NMPATH[0];
            P<NET$HEADER> = NET$NXTPID[0];
            END 
          END 
        ELSE
          BEGIN 
          DONE = TRUE;
          P<PTH$ENTRY> = NET$PATHAD[0] + (PATHORD - I - 1) * PTH$LENGTH;
          I = PATHORD;
          END 
        END 
      IF I NE PATHORD 
      THEN
        BEGIN 
        ERROR;
        END 
      ELSE
        BEGIN 
        P<RMT$ENTRY> = PTH$RMTNAD[0]; 
        ACCODE = PTH$ACCESS[0]; 
        DESTIN = RMT$DEST[0]; 
        BIT$LT[0] = PTH$LTE[0]; 
        NDCODE = RMT$NAD[0];
        BIT$RT[0] = PTH$RTE[0]; 
        P<NST$ENTRY> = LOC(RMT$NSTWD0); 
        LOGBIT = NST$LOG; 
        ASLONGAS (NOT PAR$EOC[0] AND NOT CMDERR) DO 
          BEGIN 
          GETPAR(PAR);
          IF PAR$WD1[0] EQ 0
          THEN
            BEGIN 
            CMDERR = TRUE;
            END 
          ELSE
            BEGIN 
            FOUND = FALSE;
            FOR I = 1 WHILE (I LE MAXFORPSZ AND NOT FOUND) DO 
              BEGIN 
              IF PAR$FORP[0] EQ FORC[I] 
              THEN
                BEGIN 
                FOUND = TRUE; 
                END 
              ELSE
                BEGIN 
                I = I + 1;
                END 
              END 
            IF NOT FOUND
              OR PAR$PARLEN GT FORMAXL[I] 
            THEN
              BEGIN 
              CMDERR = TRUE;
              END 
            ELSE
              BEGIN 
              GOTO CASEFORP[I]; 
# 
*     PROCESS FORMAL PARAMETER THROUGH SIMULATED CASE STATEMENT 
# 
  
AC: 
    ACCODE = HDTOBIN(PAR$PAR[0],7,CONVERR); 
    IF CONVERR LS 0 
    THEN
      BEGIN 
      CMDERR = TRUE;
      END 
    GOTO ENDCASE; 
  
DD: 
    DESTIN = HDTOBIN(PAR$PAR[0],7,CONVERR); 
    IF CONVERR LS 0 
    THEN
      BEGIN 
      CMDERR = TRUE;
      END 
    GOTO ENDCASE; 
  
LTLAB:  
    BIT$LT[0] = BDTOBIN(PAR$PAR[0],7,CONVERR);
    IF CONVERR LS 0 
    THEN
      BEGIN 
      CMDERR = TRUE;
      END 
    GOTO ENDCASE; 
  
ND: 
    NDCODE = HDTOBIN(PAR$PAR[0],7,CONVERR); 
    IF CONVERR LS 0 
    THEN
      BEGIN 
      CMDERR = TRUE;
      END 
    GOTO ENDCASE; 
  
RT: 
    BIT$RT[0] = BDTOBIN(PAR$PAR[0],7,CONVERR);
    IF CONVERR LS 0 
    THEN
      BEGIN 
      CMDERR = TRUE;
      END 
    GOTO ENDCASE; 
  
LOG:  
      IF PAR$PAR[0] EQ "YES"
      THEN
        BEGIN 
        LOGBIT = TRUE;
        END 
      ELSE
        BEGIN 
        IF PAR$PAR[0] EQ "NO" 
        THEN
          BEGIN 
          LOGBIT = FALSE; 
          END 
        ELSE
          BEGIN 
          CMDERR = TRUE;
          END 
        END 
  
# 
*     END OF SIMULATED CASE STATEMENT 
# 
ENDCASE:  
              END 
            END 
          END 
        LTCNT = 0;
        RTCNT = 0;
        FOR I = 0 STEP 1 UNTIL 3 DO 
          BEGIN 
          LTCNT = LTCNT + B<I,1>BIT$LT[0];
          RTCNT = RTCNT + B<I,1>BIT$RT[0];
          END 
        IF LTCNT NE RTCNT 
        THEN
          BEGIN 
          CMDERR = TRUE;
          END 
        IF CMDERR 
        THEN
          BEGIN 
          ERROR;
          END 
        ELSE
          BEGIN 
          PTH$ACCESS[0] = ACCODE; 
          RMT$DEST[0] = DESTIN; 
          PTH$LTE[0] = BIT$LT[0]; 
          RMT$NAD[0] = NDCODE;
          PTH$RTE[0] = BIT$RT[0]; 
          NST$LOG = LOGBIT; 
          END 
        END 
      RETURN; 
      END 
  
      TERM
