*COMDECK  COMFMFP - MARK FIRST PARAMETERS.
 MFP      CTEXT  COMFMFP - MARK FIRST PARAMETERS. 
  
  
          EXT    T.PAR,T.SCR,T=PAR,T=SCR
 MFP      SPACE  4,10 
**        MFP - MARK FIRST PARAMETERS.
* 
*         *MFP* EXISTS TO WARN THE COMMON CODE GENERATOR *BRIDGE* THAT
*         THE PARSED FILE CONTAINS TURPLE SEQUENCES FOR GENERATING
*         PARAMETERS FOR A PROCEDURE (SUBROUTINE, FUNCTION, I/O) REFER- 
*         ENCE.  SINCE *BRIDGE* MUST SPECIAL-CASE THESE SEQUENCES,
*         *MFP* TURNS ON TWO TYPES OF WARNING BITS IN THE FIRST TURPLES 
*         OF THE SEQUENCES. 
* 
*         THE FIRST BIT TYPE, *PAP* (PRECEDES ACTUAL PARAMETER), IS 
*         TURNED ON IN THE FIRST (SMALLEST PARSED FILE ORDINAL) TURPLE
*         THAT OCCURS FOR EACH PARAMETER.  THE SECOND, *PFP* (PRECEDES
*         FIRST PARAMETER), IS TURNED ON IN THE FIRST TURPLE THAT OCCURS
*         FOR ANY PARAMETER OF ONE PROCEDURE REFERENCE. 
* 
*         IN GENERAL, ONE *PFP* AND *N* *PAP* BITS ARE TURNED ON FOR A
*         PROCEDURE REFERENCE THAT HAS *N* PARAMETERS.  EXCEPTIONS... 
*         1)  IF A PARAMETER IS CONSTANT, ITS *PAP* BIT REMAINS OFF.
*         2)  IF ALL PARAMETERS FOR A REFERENCE ARE CONSTANT, OR IF THE 
*             REFERENCE HAS NO PARAMETERS, THE *PFP* BIT REMAINS OFF. 
* 
*         *MFP* IS CALLED WHEN ALL PARAMETER APLIST (ARGUMENT) TURPLES
*         FOR ONE PROCEDURE REFERENCE HAVE BEEN ENTERED IN T.PAR. 
*         *MFP* CONSIDERS AN ARGUMENT TURPLE TO BE THE ROOT OF A TREE,
*         WALKS THE TREE TO FIND ITS FIRST TURPLE, AND TURNS ON THE 
*         *PAP* BIT IN THAT TURPLE (UNLESS THE ROOT IS A TERMINAL NODE
*         - CONSTANT ARGUMENT).  EVERY ARGUMENT TREE FOR THE REFERENCE
*         IS SIMILARLY WALKED.  FINALLY, THE *PFP* BIT IS TURNED ON IN
*         THE FIRST *PAP-PED* TURPLE OF THE FOREST. 
* 
*         *WOT*, THE TREE WALK SUBROUTINE, USES THE PREORDER TRAVERSAL
*         METHOD OF KNUTH VOL. 1, P. 316.  THE ALGORITHM IS AD HOC, 
*         USING T.SCR TO STACK RIGHT BRANCH ORDINALS FOR DEFERRED 
*         TRAVERSAL.
* 
* 
*         ENTRY  ARGUMENT (APLIST) TURPLES TO BE CHECKED ARE THE
*                       LAST CONTIGUOUS ENTRIES IN T.PAR. 
*                (T=PAR) = LWO+1 OF ARGUMENT TURPLES. 
*                (T=SCR) = CURRENT LENGTH OF T.SCR. 
* 
*         EXIT   *PFP* AND *PAP* BITS SET IF ONE OR MORE NON-TERMINAL 
*                ARGUMENT TURPLES WERE ENCOUNTERED. 
* 
*         USES   ALL BUT   A0,A5    X5   B4,B5,B6.
* 
*         CALLS  WOT. 
  
  
 MFP      SUBR   =           ENTRY/EXIT...
          SA1    T=SCR
          BX6    X1 
          SA6    MFP.SCR     SAVE INITIAL LENGTH OF T.SCR 
          MX0    1
          BX7    -X0         LARGEST POSSIBLE POSITIVE INTEGER
          SA7    MFP.PFP     INIT ORDINAL OF 1ST TURPLE IN FOREST 
          SA1    T=PAR
          =X6    X1-Z=TURP+Z=TURP 
          SA6    MFP.APL     ORDINAL OF LAST ROOT 
          SA2    T.PAR
          SB7    X2          (B7) = (T.PAR) 
  
*         FOREST WALK LOOP. 
  
 MFP2     SA1    MFP.APL     GET ORDINAL OF NEXT TREE ROOT
          SX6    X1-Z=TURP
          SA6    A1 
          =B2    X6+OR.OPR
          SA1    B7+B2
          HX1    TH.SKEL
          AX1    TH.SKELP 
          SB2    X1 
          SB3    =XV=GAP
          EQ     B2,B3,MFP3  IF GENERAL AP TURPLE 
          SB3    =XV=IAP
          EQ     B2,B3,MFP3  IF INTRINSIC AP TURPLE 
          SB3    =XV=APIOD
          EQ     B2,B3,MFP3  IF I/O DATA AP TURPLE
          SB3    =XV=APIOC
          NE     B2,B3,MFP9  IF NOT I/O CONTROL AP TURPLE, END OF FOREST
  
*         WALK 1ST OPERAND TREE.
  
 MFP3     =A2    A1-OR.OPR+OR.1OP 
          =B2    A1-OR.OPR
          BX3    X2 
          IFBIT  X3,-TP.INTRP,MFP4     IF ROOT IS A LEAF
          RJ     WOT         WALK OPERAND TREE
          SA1    MFP.APL
          SB2    B7+X1
  
*         WALK 2ND OPERAND TREE.
  
 MFP4     =A2    B2+OR.2OP
          BX3    X2 
          IFBIT  X3,-TP.INTRP,MFP2     IF ROOT IS A LEAF
          RJ     WOT         WALK OPERAND TREE
          EQ     MFP2        LOOP FOR NEXT TREE 
  
*         HERE WHEN FOREST WALK DONE.  SET *PFP* BIT. 
  
 MFP9     SA1    MFP.PFP
          LX6    X1,B1
          SB2    B7+X1
          MI     X6,EXIT.    IF NOTHING PRECEDED ANY ARG TURPLE 
          =A2    B2+OR.OPR
          LDBIT  X3,TH.PFPP 
          BX6    X2+X3
          SA6    A2          SET *PFP* BIT
          EQ     EXIT.
  
  
 MFP.APL  BSS    1           T.PAR ORDINAL OF TREE ROOT (ARG TURPLE)
 MFP.PFP  BSS    1           T.PAR ORDINAL OF 1ST TURPLE IN FOREST
 MFP.SCR  BSS    1           TEMP SAVE INITIAL LENGTH OF T.SCR
 WOT      EJECT 
**        WOT - WALK OPERAND TREE.
* 
*         ENTRY  (A2,X2) = ROOT OF TREE # OPERAND OF AN ARG TURPLE. 
*                (B7) = (T.PAR) 
* 
*         EXIT   TREE HAS BEEN WALKED.
*                *PAP* BIT SET IN EARLIEST NON-TERMINAL OPERAND TURPLE. 
*                (MFP.PFP) = MIN (NEW *PAP*, OLD *PFP*) ORDINAL.
*                (B7) = CURRENT (T.PAR).
* 
*         USES   ALL BUT   A0,A5    X5   B4,B5,B6.
* 
*         CALLS  ADDWD, SHRINK. 
  
  
 WOT      SUBR               ENTRY/EXIT...
          LX2    -TP.ORDP 
          MX0    -TP.ORDL 
          BX4    -X0*X2      (X4) = ORDINAL OF NEXT NODE
          MX1    1
          BX6    -X1         LARGEST POSSIBLE POSITIVE INTEGER
          SA6    WOT.PAP     INIT ORDINAL OF 1ST TURPLE IN CURRENT TREE 
  
*         TRAVERSE SUBTREE. 
*         (X4) = ORDINAL OF SUBTREE ROOT,   (B7) = (T.PAR). 
  
 WOT2     SB2    B7+X4
          MX0    -TP.ORDL 
          =A1    B2+OR.OPR   TURPLE HEADER
          =A2    B2+OR.1OP   FIRST OPERAND (LEFT BRANCH)
          =A3    B2+OR.2OP   SECOND OPERAND (RIGHT BRANCH)
          HX1    TH.SKEL
          AX1    TH.SKELP 
          SB2    X1 
          SB3    =XV=FUNC 
          EQ     B2,B3,WOT4  IF FUNC RESULT TURPLE, ROOT IS A LEAF
          SB3    =XV=INTF 
          EQ     B2,B3,WOT4  IF FUNC RESULT TURPLE, ROOT IS A LEAF
  
*         CHECK LEFT BRANCH.
  
          IFBIT  X2,-TP.INTRP,WOT3       IF NO LEFT BRANCH
          LX2    -TP.ORDP+TP.INTRP+1
          BX4    -X0*X2 
          IFBIT  X3,-TP.INTRP,WOT2       IF NO RIGHT BRANCH 
          LX3    -TP.ORDP+TP.INTRP+1
          BX6    -X0*X3 
          ADDWD  T.SCR       STACK ORDINAL OF RIGHT SUBTREE ROOT
          SA1    T.PAR
          SB7    X1          RESTORE (B7) = (T.PAR) 
          EQ     WOT2        GO WALK LEFT SUBTREE 
  
*         CHECK RIGHT BRANCH. 
  
 WOT3     IFBIT  X3,-TP.INTRP,WOT4   IF NO RIGHT BRANCH, NODE IS A LEAF 
          LX3    -TP.ORDP+TP.INTRP+1
          BX4    -X0*X3 
          EQ     WOT2        GO WALK RIGHT SUBTREE
  
*         HERE WHEN SUBTREE TREE LEAF FOUND.  UPDATE *PAP* ORDINAL. 
*         POP STACK OF SAVED RIGHT BRANCHES.
  
 WOT4     SA1    WOT.PAP
          BX2    X4 
          MX6    X1-X2       NEW *PAP* ORDINAL = MIN ( X4, OLD PAP )
          SA6    A1 
          SA1    T=SCR
          SA2    MFP.SCR
          IX3    X2-X1
          PL     X3,WOT5     IF T.SCR EMPTY, END OF TREE
          SA2    T.SCR
          SB2    X1-1 
          SA4    X2+B2       (X4) = POPPED ORDINAL OF SAVED SUBTREE 
          SHRINK A1,B2
          EQ     WOT2        GO WALK POPPED RIGHT BRANCH
  
*         HERE WHEN TREE WALK DONE.  SET *PAP* BIT.  UPDATE *PFP* 
*         ORDINAL.
  
 WOT5     SA1    WOT.PAP
          LX6    X1,B1
          SB2    B7+X1
          MI     X6,EXIT.    IF NOTHING PRECEDED CURRENT ARG TURPLE 
          =A2    B2+OR.OPR
          LDBIT  X3,TH.PAPP 
          BX6    X2+X3
          SA6    A2          SET *PAP* BIT
          SA2    MFP.PFP
          MX6    X1-X2       NEW *PFP* ORDINAL = MIN (NEW PAP, OLD PFP) 
          SA6    A2 
          EQ     EXIT.
  
  
 WOT.PAP  BSS    1           T.PAR ORDINAL OF 1ST TURPLE IN CURRENT TREE
  
  
          ENDX
