Batch jobs can be submitted either via cards or via time sharing or via R/C under DCMCP. All batch commands begin with a ? character. To run a job under a specific user the first card should be ?USER <name>. The two primary batch commands are ?COMPILE or ?EXECUTE. Following these cards comes the ?FILE cards to specify how files are to be accessed. Typical files are CARD for card input, TAPE for input from tape/disk, or LINE which specifies where the output of the program will go.

The common structure of a compile deck is as follows:

?COMPILE <executable> [WITH] <language> [FOR] <option>

The words WITH and FOR are optional. <option> can be GO which causes the program to be execute if compile is successful. LIBRARY if you just wish to compile the program to be executed at a later date. SYNTAX compiles the program but does not generate any output.

? <language> FILE LINE = PRINT BACK UP DISK

This caused the output of the compiler to be printed on the printer.

? <language> FILE TAPE = <source> SERIAL DISK

Indicates that the input will also come from a tape file and be merged in with what is on the card reader.

? <language> FILE NEWTAPE = <new source> SERIAL DISK

Optional card the creates a new version of the source file merged with the input cards. Also the first card the dollar card has to include NEW TAPE option.

? FILE LINE = PRINT BACK UP DISK

Sends the output of the program to the printer.

? DATA CARD

This indicates that the following will be read as data until the next ? card. For a compiler the next card is typically a $ card which specifies the compiler options. Typical this might be:

$ CARD LIST SINGLE

This will take input only from the card deck and list the program single space. The default listing is double spaced. Some other common options are PRT to list program segments in the listing. This will help in debugging. TAPE to merge the card deck with the TAPE file. NEW TAPE to create a new merged deck for later compile.

Following the program there can be another ? DATA <name> card to give the program more data. Or an ?END card to terminate the input.

The following is an example program that will copy the file CARD to the file NEWTAPE.

?COMPILE O/RDR WITH ALGOL FOR LIBRARY  
?ALGOL FILE LINE = PRINT BACK UP DISK
?DATA CARD
$CARD LIST SINGLE
BEGIN                                                                   0001000
LABEL EOF;                                                              0014000
SAVE  ARRAY REC[0:15];                                                  0015000
FILE IN CARD (2, 10);                                                   0016000
SAVE FILE OUT  NEWTAPE DISK SERIAL [20:3000] (2,10,150,SAVE 99);        0018000
                                                                        0020000
WHILE TRUE DO                                                           0027000
 BEGIN                                                                  0028000
 READ(CARD, 10, REC[*]) [EOF];                                          0030000
 WRITE(NEWTAPE, 10, REC[*]);                                            0034000
 END WHILE;                                                             0036000
                                                                        0037000
EOF:                                                                    0038000
LOCK(NEWTAPE,RELEASE);                                                  0040000
CLOSE(CARD)                                                             0042000
END.                                                                    0045000
END.    LAST CARD ON 0CRDING  TAPE                                      9999999
?END


The program can be run with the ?EXECUTE card as follows:

?EXECUTE O/RDR
?ALGOL FILE NEW TAPE = SYMBOL/RDR SERIAL DISK
?DATA CARD
BEGIN                                                                   0001000
LABEL EOF;                                                              0014000
SAVE  ARRAY REC[0:15];                                                  0015000
FILE IN CARD (2, 10);                                                   0016000
SAVE FILE OUT  NEWTAPE DISK SERIAL [20:3000] (2,10,150,SAVE 99);        0018000
                                                                        0020000
WHILE TRUE DO                                                           0027000
 BEGIN                                                                  0028000
 READ(CARD, 10, REC[*]) [EOF];                                          0030000
 WRITE(NEWTAPE, 10, REC[*]);                                            0034000
  END WHILE;                                                            0036000
                                                                        0037000
EOF:                                                                    0038000
LOCK(NEWTAPE,RELEASE);                                                  0040000
CLOSE(CARD)                                                             0042000
END.                                                                    0045000
END.    LAST CARD ON 0CRDING  TAPE                                      9999999
?END
 


This would store the source for the program on disk. The generated system image comes with a much more functional version of this program called OBJECT/READER, which by default will copy the file S to LINE, this is a simple way to print out program source. By using the ?COMMON = # option card after the ?EXECUTE card the operation of the program can be controlled. ?COMMON = 1 copies CARD to LINE, this can be used to print a card deck or copy cards to a file.?COMMON = 2 copies the file from S to both LINE and NEWTAPE, this can be used to copy a source file to a new name. ?COMMON =3 copies CARD to LINE and NEWTAPE this is the preferred way to load a source deck. For example as follows:

?EXECUTE OBJECT/READER
?COMMON = 3
?FILE NEWTAPE = <source> DISK SERIAL
?DATA CARD
<program>
?END