*DECK  FORM 
      PRGM  FORM;            # FORM 1.1 MAIN ROUTINE                   #
#                                                                      #
#       FORM 1.1  -  FILE ORGANISOR AND RECORD MANAGER PROGRAM         #
#                                                                      #
#         COPYRIGHT CONTROL DATA CORP.  1978, 1979, 1980, 1981, 1982.  #
#                                                                      #
#       FORM PROVIDES GENERALIZED FILE COPY AND RECORD REFORMATTING    #
#         CAPABILITIES.                                                #
#                                                                      #
 #
* *   FORM - MAIN PROGRAM 
* *   M.T. KAUFMAN
* 1DC FMCONV
* 
* DC  FUNCTION
* 
*     LOADS AND UNLOADS THE CAPSULES REQUIRED FOR A FORM RUN. 
*     CALLS FMCRACK AND FMRUN TO PERFORM THE WORK.
* 
* DC  ENTRY CONDITIONS
* 
*     NONE. 
* 
* DC  EXIT CONDITIONS 
* 
*     NONE. 
* 
* DC  ERROR CONDITIONS
* 
*     NONE. 
* 
 #
CONTROL EJECT;
      BEGIN 
#CALL FMCOM                                                            #
*CALL FMCOM 
CONTROL EJECT;
  
        ARRAY  LOADGROUP  S(1); 
          ITEM
            GROUPNAME   C(0,0,4)   = ["BIT8"],
            GROUPFILL   U(0,24,36) = [ 0 ]; 
  
        XREF
          BEGIN 
            FUNC  FDL$LDC  I;   # CAPSULE LOAD                         #
            FUNC  FDL$ULC  I;   # CAPSULE UNLOAD                       #
            ARRAY  FM$LIST;;    # LIBRARY LIST                         #
            ARRAY  FM$PASS;;    # PASSLOCS                             #
            PROC  FM$ERR; 
            PROC  FM$CRAK;      # ENTRIES TO CAPSULES                  #
            PROC  FM$EXIT;
            PROC  FM$RUN; 
            PROC  FM$STAT;
            PROC  FM$CALL;      # INDIRECT CALL ROUTINE                #
          END 
  
        DEF  STARTLOADMAX # 5 #;
        ARRAY  STARTLOAD [1:STARTLOADMAX]  P(1);
          ITEM
            START$MODULE  C(0,0,7) =
              ["T8.COM1", "T8.COM2", "FM$TEST", "FM$UTIL", "FM$CRAK" ], 
            START$MFILL   U(0,42,18) = [0,0,0,0,0]; 
        DEF  STARTUNLOAD   # 5 #; 
  
        DEF  ENDLOADMAX    # 1 #; 
        ARRAY  ENDLOAD   [1:ENDLOADMAX]  P(1);
          ITEM
            END$MODULE    C(0,0,7) =
              ["FM$STAT"],
            END$MFILL     U(0,42,18) = [ 0 ]; 
  
        DEF  RUNLOADMAX # 7 #;
        ARRAY  RUNLOAD [1:RUNLOADMAX] P(2); 
          ITEM
            RUN$MODULE  C(0,0,7) =
              [  , "FM$PARS", , "FM$CONV", , , ], 
            RUN$MOD1    C(0,0,6) =
              [ "FM$RUN", , "FM$PRT", , , "T8.CHK", "T8.C6." ], 
            RUN$FIL1    U(0,36,6) = [ 0, , 0, , , 0, 0 ], 
            RUN$MOD2    C(0,0,5)  = [ , , , , "XREAD", , ], 
            RUN$FIL2    U(0,30,12)= [ , , , , 0, , ], 
            RUN$MFILL   U(0,42,18)= [ 0, 0, 0, 0, 0, 0, 0 ],
            RUN$FLAGS   U(1) =
              [    O"77",     O"16",     O"01",     O"06",
  
                   O"40",     O"60",     O"46" ]; 
  
        ARRAY  TEST6; 
          ITEM
            TEST6$MODULE  C(0, 0, 7) = [ "T8.TST6" ], 
            TEST6$FILL    U(0,42,18) = [ 0 ]; 
        DEF  TEST6$FLAGS  # O"36" #;
  
        ARRAY  STATS; 
          ITEM
            STAT$MODULE  C(0, 0, 7) = [ "FM$STAT" ],
            STAT$MFILL   U(0,42,18) = [ 0 ];
  
        STATUS  ERR          # ERROR ORDINALS                          #
          LDC$1, ULC$1, 
          LAST$ERR; 
  
        ARRAY  ERR$MSG  [0: 5] S(1);
          ITEM  ERR$MSG$TEXT  C(0,0,10) = [ 
  
#  LDC$1         #
      "CANNOT LOA", "D CAPSULE:", 
#  ULC$1         #
      "CANNOT UNL", "OAD CAPSUL", "E        :", 
#  LAST$MSG      #
      "******** :" ]; 
CONTROL EJECT;
      PROC  ERROR (TYPE);    # ERROR HANDLER                           #
        ITEM  TYPE  S:ERR;
      BEGIN 
        FM$ERR (0, 0, ERR$MSG, TYPE, TRUE); # FATAL ERROR              #
      END; # ERROR #
CONTROL EJECT;
        FOR  I = 1 TO STARTLOADMAX  DO      # LOAD INITIAL CAPSULES    #
          BEGIN 
            IF  FDL$LDC (LOADGROUP, START$MODULE[I], FM$PASS, FM$LIST)
                NQ 0
              THEN  ERROR(ERR"LDC$1");
          END 
        FM$CALL (FM$CRAK);   # START BY CRACKING CONTROL CARDS         #
  
        FOR  I = STARTUNLOAD TO STARTLOADMAX  DO  # UNLOAD CRACKER     #
          BEGIN 
            IF  FDL$ULC (LOADGROUP, START$MODULE[I], FM$PASS) NQ 0
              THEN  ERROR(ERR"ULC$1");
          END 
  
        FOR  I = 1 TO RUNLOADMAX  DO    # LOAD RUN-TIME CAPSULES       #
          BEGIN 
            IF  (LFLAGS LAN RUN$FLAGS[I]) NQ 0  THEN
              BEGIN 
                IF  FDL$LDC (LOADGROUP, RUN$MODULE[I], FM$PASS, 
                             FM$LIST) NQ 0
                  THEN  ERROR (ERR"LDC$1"); 
              END 
          END 
        IF NOT L$IBMW AND (LFLAGS LAN TEST6$FLAGS) NQ 0  THEN 
          IF  FDL$LDC (LOADGROUP, TEST6, FM$PASS, FM$LIST) NQ 0 
            THEN  ERROR (ERR"LDC$1"); 
        IF  LFLAGS EQ 0  THEN 
          IF  FDL$LDC (LOADGROUP, RUN$MODULE[1], FM$PASS, FM$LIST) NQ 0 
            THEN  ERROR (ERR"LDC$1"); 
        FM$CALL (FM$RUN); 
  
        IF  FDL$LDC (LOADGROUP, STATS, FM$PASS, FM$LIST) NQ 0 
          THEN  ERROR (ERR"LDC$1"); 
        FM$CALL (FM$STAT);   # PRINT SUMMARY STATISTICS                #
  
        FM$EXIT;             # END RUN                                 #
  
      END 
      TERM
