Digital PDFs

AA-D303A-TB

May 1978

96 pages

Original

3.4MB

Document:	Getting Started With Batch Aug78
Order Number:	AA-D303A-TB
Revision:	0
Pages:	96
Original Filename:	AA-D303A-TB_Getting_Started_With_Batch_Aug78.pdf

OCR Text

GETTING STARTED
WITH BATCH (TOPS-10)
AA-D303A-TB
August 1978
This document describes to the reader how to
get started with the TOPS·1 0 GALAXY Batch System.

OPERATI NG SYSTEM:

TOPS-10 Version 6.03A

SOFTWARE VERSION:

GALAXY Version 3

To order additional copies of this document, contact the Software Distribution
Center, Digital Equipment Corporation, Maynard, Massachusetts 0'1754

digital equipment corporation · maynard. massachusetts

First Printing, August 1978

The information in this document is subject to change without notice
and should not be construed as a commitment by Digital Equipment
Corporation. Digital Equipment Corporation assumes no responsibility
for any errors that may appear in this document.
The software described in this document is furnished under a license
and may be used or copied only in accordance with the terms of such
license.
Digital Equipment Corporation assumes no responsibility for the use or
reliability of its software on equipment that is not supplied by
DIGITAL or its affiliated companies.

The postage-prepaid READER'S COMMENTS form on the last page of this
document requests the user's critical evaluation to assist us in
preparing future documentation.
The following are trademarks of Digital Equipment Corporation:
DIGITAL
DEC
PDP
DECUS
UNIBUS
COMPUTER LABS
COMTEX
DDT
DECCOMM

DECsystem-lO
DEC tape
DIBOL
EDUSYSTEM
FLIP CHIP
FOCAL
INDAC
LAB-8
DECSYSTEM-20

MASSBUS
OMNIBUS
OS/8
PHA
RSTS
RSX
TOPS-IO
TOPS-20
TYPESET-8
TYPESET-II

CONTENTS

Page
PREFACE

REFERENCES

CONVENTIONS USED IN THIS MANUAL

vii

SYMBOLS USED IN THIS MANUAL

viii
Glossary-l

GLOSSARY
CHAPTER

INTRODUCTION

1-1

1.1
1.2
1.2.2
1.2.3
1.3

WHAT BATCH IS
HOW TO USE BATCH
Running Your Job
Receiving Your Output
Recovering from Errors
SUMMARY

1-1
1-2
1-2
1-3
1-3
1-3

ENTERING A BATCH JOB FROM A TERMINAL

2-1

2.1
2.1.1
2.2
2.2.1
2.2.2
2.2.3
2.3
2.3.1
2.3.2
2.3.3
2.3.4
2.3.5
2.4

CREATING THE CONTROL FILE
Format of Lines in the Control File
SUBMITTING THE JOB TO BATCH
General Switches
File-Control Switches
Examples of Submitting Jobs
BATCH COMMANDS
The .IF Command
The .ERROR Command
The .NOERROR Command
The .GOTO Command
The .BACKTO Command
SPECIFYING ERROR RECOVERY IN THE CONTROL
FILE

2-2
2-3
2-5
2-6
2-7
2-7
2-8
2-9

ENTERING A BATCH JOB FROM CARDS •

3-1

3.1
3.2
3.2.1
3.2.2
3.2.3
3.2.4
3.2.5
3.2.6
3.2.7

BATCH CONTROL CARD FORMAT CONVENTIONS
BATCH CONTROL CARD COMMANDS
Starting a Job - The $JOB Card
Identifying Yourself - The $PASSWORD Card
Ending a Job - The $EOJ Card
Creating a File - The $CREATE Card
Compiling a Program - The $-language Card
Executing a Program - The $EXECUTE Card
Executing a Program with Data - The $DATA
Card

3-2
3-2
3-2
3-5
3-5
3-5
3-7
3-9

1.2~1

CHAPTER

iii

2-~

2-10
2-11
2-12
2-12

3-10

CONTENTS (CONT.)

Page
Reading from a Spooled Card-Reader File
Naming Data Files on the $DATA Card
End of Data Input - The $EOD Card
System Commands - The $TOPSlO Card
Error Recovery - The $ERROR and $NOERROR
Cards
SETTING UP YOUR CARD DECK
PUTTING COMMANDS INTO THE CONTROL FILE FROM
CARDS
Card Decks for Programs that Do Not Have
Special Control Cards
SPECIFYING ERROR RECOVERY IN THE CONTROL
FILE

3-12
3-14
3-16
3-16

INTERPRETING YOUR PRINTED OUTPUT

4-1

4.1
4.2
4.3
4.4
4.4.1
4.4.2

OUTPUT FROM YOUR JOB
BATCH OUTPUT
OTHER PRINTED OUTPUT
SAMPLE BATCH OUTPUT
Sample Output of a Job from a Terminal
Sample Output of a Job on Cards

4-1
4-1
4-2
4-2
4-2
4-4

EXAMPLES OF COMMON TASKS WITH BATCH

5-1

5.1
5.2

USING THE TERMINAL TO ENTER JOBS
USING CARDS TO ENTER JOBS

5-1
5-10

3.2.7.1
3.2.7.2
3.2.8
3.2.9
3.2.10
3.3
3.4
3.4.1

3.5
CHAPTER

CHAPTER

3-18
3-20
3-21
3-23
3-26

Index-l

INDEX

FIGURES

FIGURE

3-1
3-2
3-3
3-4
3-5
3-6
3-7
3-8
4-1
5-1
5-2
5-3

5-4

Batch Card Deck Using TOPS-lO Commands
Typical Program Card Deck
Use of Control Cards to Compare Two Card Decks
BASIC Program Card Deck with Integral Data
BASIC Program Card Deck with Provisions
for Terminal Data Input
Card Deck with Error Statement
Card Deck with Error Recovery Program
Card Deck Using GOTO Statement
COBOL Print Program Card Deck
ALGOL Job Entry Card Deck
BASIC Job Entry and Run Card Deck
FORTRAN Card Deck That Prevents
Execution on Error
COBOL Program Card Deck Using Data From
Magnetic Tape

3-18
3-20
3-22
3-24

3-25
3-26
3-28
3-30
4-4
5-10
5-12
5-14

5-18

PREFACE

Getting Started With Batch (TOPS-lO) has been written for you, if you
have a rudimentary knowledge of Batch processing or are familiar with
at least one of the following:
1.

a programming language

the

card processing on other systems

ti~esharing

services of the DECsystem-lO

HOW TO USE THIS MANUAL
If you input your jobs through interactive
chapters are recommended:

terminals,

the

following

Chapter 1

Introduction

Chapter 2

Entering a Batch Job from a Terminal

Chapter 4

Interpreting Your Printed Output, Section 4.4.1

Chapter 5

Using the Terminal to Enter Jobs, Section 5.1

If you input
recommended:

your

jobs

from

cards,

the

following

chapters

Chapter 1

Introduction

Chapter 3

Entering a Batch Job from Cards

Chapter 4

Interpreting Your Printed Output, Section 4.4.2

Chapter 5

Using Cards to Enter Jobs, Section 5.2

are

REFERENCES

Not all of the commands and card formats for Batch processing are
described in this manual. If you want to know more about Batch you
can refer to the DECsystem-IO (TOPS-IO) Batch Reference Manual.
In
addition, all components of Batch processing are referred to as Batch
in this manual. For a complete description of these components, refer
to the DECsystem-IO (TOPS-IO) Batch Reference Manual.
An elementary description of the basic TOPS-IO system commands can be
found in the documents Getting Started with DECsystem-IO (TOPS-IO) and
Getting Started With TOPS-IO Commands.
The DECsystem-IO
(TOPS-IO)
Operating System Commands Manual contains additional descriptions of
the TOPS-IO commands available to you.
Error messages that occur while Batch is processing but which are not
defined ln this manual are explained in applicable system manuals.
For example, if your FORTRAN program fails to compile successfully,
the error message you receive from the FORTRAN compiler can be found
in the FORTRAN-IO Programmer's Reference Manual. For errors that may
occur in a Batch process but not in the source program being used, you
can refer to the DECsystem-IO (TOPS-IO) Batch Reference Manual.

CONVENTIONS USED IN THIS MANUAL

The following is a list
manual.

symbols

and

conventions

used

this

dd-mmm-yy hh:mm

A set of alphanumeric characters that indicates
date and time; e.g., 2-APR-78 15:30. Time of day
is represented by a 24-hour notation; 15:30 means
3:30 P.M.

filename.ext

The filename and file extension of a file.
The
filename can be 1 to 6 alphanumeric characters in
length and the file extension can be 1 to 3
alphanumeric
characters in length.
The file
extension may be optional. If present, the file
extension must be separated from the filename with
a periooo
Refer to the
Glossary
for
the
definitions of these terms.

hh:mm:ss

A set of numbers representing time in the form
hours:minutes:seconds.
. Leading
zeros can be
omitted, but colons must be present between two
numbers.
For example, 5:35:20 means 5 hours, 35
minutes, and 20 seconds.

jobname

The name that is assigned to a job.
contain up to six characters.
Refer
Glossary for the definition of a job.

A number that specifies either a required number
or
an
amount
of things such as cards or
line-printer pages. This number can contain as
many digits as are necessary to specify the amount
required, e.g., 5, 13, 219, etc.

[proj,prog]

The user number assigned to each user, commonly
called
a project-programmer number.
The two
numbers that make up the project-programmer number
must be separated by a comma.
Refer to the
Glossary
for
the
definition
of
a
project-programmer number.

A number representing an amount of time, usually
in minutes.
This number can contain as many
digits as are necessary to specify the amount of
time required, e.g., 7, 40, 120, etc.

An alphanumeric character.

vii

It
to

can
the

SYMBOLS USED IN THIS MANUAL

Symbol

Meaning

• TYPE

Anything you type on your terminal appears in red •
Anything the system prints on your terminal appears
in black.
Press the key labeled RETURN or CR.
Press the key labeled DELETE or RUBOUT.
Press the key labeled ESC, ESCAPE, ALT, or PRE.
Press the key labeled TAB.
Press the space bar once.

[

]

Brackets enclose all optional arguments.

(

)

Parentheses enclose the name or value of an argument.

viii

CHAPTER 1
INTRODUCTION

1.1

WHAT BATCH IS

Many data processing jobs may require long running times and may make
few demands of you. Ideally these jobs should be run ln your absence
when the computer is not busy with other tasks. This ideal is met by
the TOPS-IO Batch system.
Batch is a group of, programs that allows you to submit a job to the
TOPS-IO system on a leave-it basis.
(Refer to the DECsystem-lO
(TOPS-lO) Batch Reference Manual for a complete description of
programs that constitute the Batch sy~tem.) You may build and submit
your job in one of two ways:
1.

By entering your data directly to an interactive
system by means of a timesharing ,terminal.

computer

By entering your data from punched-cards to the interactive
system.
The cards are given to an operator who, at an
appropriate time in his schedule, enters them into the
computer through a card reader.

One advantage of Batch processing with an interactive system is that
the interactive capabilities may be employed to greatly reduce the
amount of time required to prepare the job fo[ entry.
By using a
terminal to enter and edit the program items and data to be processed,
you can bypass the tedious chore of preparing card decks. However, if
desired, you can prepare traditional card decks by employing the
punched card facilities of the system.
In either
case,
the
information to be entered is prepared as if it were to be processed as
a normal job from an interactive terminal. The only added requirement
is that special commands are entered with the job to direct the system
in your absence. In other words, you anticip2~e the questions the
system
normally asks and you answer them when you enter the
interactive job.
After preparing the job, you are free to leave the system.
Upon
accepting the job, the system classifies it in terms of size, running
time, the need for peripherals, etc. This classification is used as
the basis for determining when the job is to be run. Large jobs may,
therefore, be set aside until smaller or more urgent jobs are
finished.

1-1

INTRODUCTION
Some of the jobs that are commonly processed through the TOPS-IO Batch
system are those that:
1.

are frequently run for production

are large and long running

require large amounts of data

need no actions by you when the jobs are running

Batch allows you to submit your job to the computer through either a
card deck given to an operator or a timesharing terminal, and to
receive your output from the operator when the job has finished.
Output is never returned to your timesharing terminal even if your job
is entered from one. Instead, it is sent to a peripheral device
(normally the line printer) at the computer site and returned to you
in the manner designated by the installation manager.

1.2

HOW TO USE BATCH

To use the Batch system to process your job, you must create a-control
file.
A control file consists of various commands that tell the
TOPS-IO system what you want to process. The control file commands
can be created as a disk file or as card input and can consist of:
1.

System commands (see the
System Commands Manual),

DECsystem-IO

(TOPS-IO)

System program commands to system programs, and

Batch commands (see Chapters 2 and 3).

Operating

These commands, when submitted to the operating system, must be
particular order so that your Batch job will execute correctly.

The steps that you must take to create a control file from a
timesharing terminal are described in Chapter 2. The steps to take to
create a control file from cards are described in Chapter 3.

1.2.1

Running Your Job

After you submit the job, it waits in a queue with other jobs until
Batch schedules it to run under guidelines established by the
installation manager. Several factors affect how long your job waits
in the queue, for example, its estimated execution time and the
priority of your job compared with other waiting jobs.
When the job is started, Batch reads the control file to determine
what actions are necessary to complete the job. For example, if there
are commands to the system programs, Batch issues the commands to
those programs. Any output produced as a result of those commands is
stored in a log file for listing later. With adequate planning, the
control file can also provide for corrective actions in the event of
errors.

1-2

INTRODUCTION
As each step in the control file is performed, Batch records it in a
log file.
For example, if a system command such as COMPILE is
executed, Batch passes it to the system and writes it in the log file.
The system response is also written in the log file. Batch writes in
the log file any response from your job that would have been written
on the terminal if the job had run interactively.

1.2.2

Receiving Your Output

Your program output will be returned to you in the form that you
specified by the commands in your control file. This is normally the
line-printer listing, but may also be output on m~gnetic tape, disk,
DECtape, or cards. When your output is directed to the line printer,
you may specify the approximate number pf pages that you require
(to
help Batch restrain runaway programs).
If your Batch job is submitted through a timesharing terminal, the log
file is written and saved on disk in your directory and printed on the
line printer. If your Batch job is submitted on card input, the log
file is written on disk in your dir~ctory, printed on the line
printer, and then deleted from your directory.

Recovering from Errors

1.2.3

If an error occurs in your job, either within a program that is
executing or within the control file, Batch writes the error message
in the log file and usually terminates the job.
You can, however,
include commands in the control file to direct Batch to b(anch to
recovery sequences in the event of an error and thereby allow
completion of the job.
The effectiveness of error recovery is
dependent on your ability to predict potential trouble spots within
the program or within commands used in the control file.
(Refer to
the DECsystem-lO (TOPS-IO) Batch Reference Manual for
detailed
descriptions on error recovery for Batch jobs.)

1.3

SUMMARY

The steps that you must perform to enter a job to the computer through
Batch are as follows:
1.

Create a control file either on cards or from a terminal.

Submit the job to Batch, either indirectly via
(for a card job) or directly from a terminal.

Obtain and examinE~ the log file listing and the job output to
determine if the desired results were obtained.

the

operator

Sample jobs run through Batch from cards and from a terminal are shown
in Chapter 5.

1-3

CHAPTER 2
ENTERING A BATCH JOB FROM A TERMINAL

When you submit a job to Batch from a timesharing terminal, you must
create a control file that Batch can use to run your job. The control
file contains all the commands that you would use to run your job if
you were running under timesharing. For example, if you wanted to
compile and execute a program called MYPROG.CBL, the typeout on a
timesharing terminal would appear as follows:

.COMPILE MYF'~:OG. CSL QID
COBOL: MYPROG [MYPROG.CBL]

(Your request)
(The system's reply)

EXIT
.EXECUTE MYPROG. CBL GD
LINK:
LOADING
[LNKXCT MYPROG EXECUTIONJ

(Your request)
(The system's reply)

EXIT
To create a ~ontrol file to tell Batch to
create the following:

run

the

same,

you

would

G:)

.808 MYFILE.CTLC§]
INPUT: MYFILE.CTL
00100
.COMF'ILE MYPHOG.CBLCili)
00200
.EXECUTE MYF'ROG.CBL~
00300
$
*E~

[DSKC:MYFILE.CTLJ

When the job is run, the commands are passed to the system to be
executed.
The commands and their replies from the system are written
in the log file so that the entire dialogue shown in the first example
above appears in the log file.

2-1

ENTERING A BATCH JOB FROM A TERMINAL
2.1

CREATING THE CONTROL FILE

To create a control file and submit it to Batch from a
must perform the following steps:

terminal,

Create a control file on disk using SOS (or TECO).

Submit the job to Batch using the system command SUBMIT.

You can then wait for your output to be
place.

returned

the

you

designated

After you have logged into the system as you normally would to start a
timesharing job, you can use SOS (or TECO) to create your control
file.
The control file can contain TOPS-IO Monitor commands, program
commands, data that would normally be entered from a terminal, and
Batch commands. The Batch commands are described in Section 2.3.
What you write in the control file depends on what you wish your job
to accomplish. An example of a job that you can enter for Batch
processing is as follows:
1.

Compile a program that is on disk.

Load and execute the program using data from a
on disk.

Print the output on the line printer.

Write the output into a disk file also.

Compile a second program.

Load and execute the second program
from the first program.

Print the output from the second program.

The control file that you would create for
appear as follows:

using

the

• 80S MYF ILE. CTL G0
INPUT:
MYFILE.CTL
00100
.COMPILE MYPROG.FOR/CDMPILEG!D
00200
• EXECUTE MYf'ROG. FOI:~GI0
00300
• COMP I LE PROG2. For~/CDMP I LE~D
00400
• EXECUTE PROG2. FOR ~
00500
$

GD
*E~
[DSKC:MYFILE.CTLJ

2-2

file

already

data

output

job

would

the

preceding

ENTERING A BATCH JOB FROM A TERMINAL
Include statements in your programs (rather than in the control file)
to read the data from the disk files and write the output to the
printer and the disk. The output to the line printer is written along
with your log file as part of the total output of your job.
If an error occurs in your job, Batch will not continue but will
terminate the job.
To avoid having your job terminated because an
error occurs, you can specify error recovery in the control file using
special Batch commands. Error recovery is described in Section 2.4.
Any system command that you can use in a timesharing job can be used
in a Batch job with the following exceptions. The ATTACH and SET TIME
commands are illegal in a Batch job. If you include either of these
commands in your job, Batch will process the command and the monitor
will place an error message into your log file. Your Batch job will
terminate unless you specify error recovery.
Do not include a LOGIN command in your control file since Batch logs
the job for you.
If you put in a LOGIN command, your job will be
terminated. In addition, you do not need to include a KJOB command.
Batch will log out your j()b automatically when it reaches the end of
your control file.

2.1.1

Format of Lines in the Control Pile

Since you can put TOPS-IO monitor commands, program commands, and
Batch commands, as well as data, into the control file, you have to
tell Batch what kind of line it is reading •. Batch determines the line
it is reading as a command, data, or comment by the first non tab or
nonblank character. The first character in each line should be one of
the characters described below.
To put a system command or Batch command into your control file, you
must put a period (.) in the first column and follow it immediately
with the command.
To put a command string of a system program or user program into your
control file, put an asterisk (*) in column I and follow it
immediately with the command string. For the format of the command
string, refer to the manual for the specific program that you wish to
use.
If you want to include in the control file a command to a system
program that does not accept a carriage return as the end of the line,
e.g., DDT, you must substitute an equal sign (=) for the asterisk so
that Batch will suppress the carriage return at the end of the line.
To include data for your program in the control file, write it as you
would input data from a separate file. The asterisk (*) should always
be the first character before each line of data input.
The asterisk
(*) tells Batch that this line is input data to your program.
Comments can also be included in the control file either as separate
lines or on lines containing other information. To include a comment
on a separate line, you must put an exclamation point (1) in column 1
and follow it with the comment. To add a comment to a line after your
data, you must precede the comment with an exclamation point (1).
Refer to the manual that describes the program you are using, as some
programs and their input do not accept comments preceded by the
exclamation point (1).

2-3

ENTERING A BATCH JOB FROM A TERMINAL
To include a CTRL/C in your control file, type an up-arrow and a C
(ftC).
To include an ESCape (altmode), type an up-arrow and a left
square bracket (ft[).
If you put in the first column of the line any special characters
other than those described, you may get unexpected results because
Batch interprets other special characters in special ways.
The following example illustrates a control file, using some of the
characters described above, and the resulting log file. The example
uses the TOPS-10 FILCOM utility to compare two files.
!This batch job generates a FILCOM of two files.
!Run FILCOM and then give it a command .
. R FILCOM
*TTY:=FILE.QXT,FILE.TXT
*"'C
08.48,07 BAJOB
01148,07 BArlt"
"114SI0? SA'IL
08148107 BASUM
08,41101 MONTft
08'4"07 MONTP
0'.48107 USEft
08.48109 USEP
oe,48.09 USEP
08.48110 MONTP
08,49,10 MONT'
01 48 10 MONTP

48 10 ustP
48 11 USEP
48 11 USER
48 11 USER
48 11 UsE):!
48 11 USER
48 11 USE):!
48 11 USEP
1)8 48 11 US~P
08 48 11 USEP
08 48 11 USEP
08 48 11 USER
08 48 11 US!):!
08149 11 ueEP

08
08
08
08
01
08
08
08

08148 11 ~ONTP.
08.48 t t MONTR

BATeON yerllon 10)(2207) rUnn1n; EXAM2 I.quene. 5902 in .tr.am I

Input from DS~CIEXAM2.CTL[27,5107]
Output to DSKCIEXAM2.LOG[Z7,510?)
JOb peram.terl
Tim.,nOI05,oO
unlQue,y!.
pe.tartlNO

Output'LOG

.LOGIN 27/5107 IDE'IR/IPOOLIALL/TIMEIJOO/LOCATE,26/NAME."BMOWN,E"
JUe 42
~ZJ76B KLtO SyS'1026 TTY45]

(LGNJIP oth.r jobl '.~I PP~'29J

0848

O'.Au;-78

TUI

•&Thl1 BatOh job ;entrate. a rILCOM of two f111"
IPun rILCOM and thin ;lYI it a eommand.
.~

fXLCOM

•• TTYlwrlLE.TIT,FILE.TXT
r111 I) DS'ClftLE.TSTl27,5107l cre.tld, 0146 OI-AuO-t97.
'11e 2) D8'ClrILE.TxTC2',5101] ereatede 0846 01-AuO-1918
1)1

Thl1 flle eontalnl a IPellnO .rror.

••••
2)1
file doe. not contein a .pell1n; error,
••••••••••••••
T~l.

'tll,. ar. dlff,rent

•• I(JOB/BATCH

n8148 tt USEP
08148 11 USEFI
01148 13 US[P
08148 1) UIER
08148 11 USEP
08a48 1:1 USEP

[LGTAJL Another ,ob l' .tlll 1009'd-ln Under [21,5107]J
JOb 42 u.er BROWN,E tZ1,5101l
LOo;.d-off TTy4,] at 8148111 on l-AU;-18
Puntl~.1 0.00100, KC114, Conn.ct tim., 0,00106
011~ R.ad.,S9, Wrlte •• ,

8148114 LPDAT
A.48114 LPDAT

LPTSpL Ylr.lon t01(2421)
pZ31~8 I(wl0 5Y5.1026
Job EXAM~ lequenCe _5902 on t"PTZ61 ~T l-AU;-'. 8'48114

2-4

ENTERING A BATCH JOB FROM A TERMINAL
2.2

SUBMITTING THE JOB TO BATCH

After you have created the control file and saved it on disk, you must
enter it into the Batch queue so that it can be run. All programs and
data that are to be processed when the job is run must be made up in
advance or be generated during the running of the job. You can have
them on magnetic tape, but if you do, you must include the TOPS-IO
commands MOUNT arid DISMOUNT in your control file so that the operator
will mount and dismount the tape(s} to be read.
(Refer to Chapter 5
for examples of a control file with these commands.)
If your programs and data reside on an on-line disk, you need not
include the MOUNT and DISMOUNT command as th~re is no action required
by the operator.
You enter your job in Batch's queue by means
command. This command has the form:

the

TOPS-IO

SUBMIT

.SUBMIT jobname=control-filnam.ext/switches,log-filnam.ext/switches
jobname

is the name that you give to your
job.
If
this name is omitted, the monitor uses the
name of the log file (log-filnam.ext).

control-filnam.ext

is the name that you have given to the
control file you created. You can add a file
extension (.ext), but if you do not, Batch
will assume a file extension of .CTL.

log-filnam.ext

is the name of the log file that Batch will
use.
You can add a file extension (.ext),
but if you do not, Batch will assume a file
extension of .LOG.

You must specify the name of the control file.
If the name of the log
file is omitted, its name will be taken from the name of the control
file.
/switches

are switches to Batch to tell it how to
process your job and what your output will
look like. Most switches can appear anywhere
in the SUBMIT command string; however, a few
must be placed after the files to which they
pertain.
The various kinds of switches are
described below.

Three categories of switches are available to you when you use the
SUBMIT command to process your Batch job. These three categories are:
1.

Queue-Operation switches,

General switches, and

File-Control switches.

Only one of the Queue-Operation switches can be placed in the command
string because this category defines the type of queue request. The
switch used can appear anywhere in the command string. Refer to the
DECsystem-IO
(TOPS-IO) Batch Reference Manual and/or the DECsystem-lO
(TOPS-IO) Operating System Commands Manual for a complete list of
Queue-Operation switches in the SUBMIT command • .

2-5

ENTERING A BATCH JOB FROM A TERMINAL
2.2.1

General Switches

You use the general switches to define limits for your job.
Such
limits as pages of output and the time that your job will run can be
specified as general switches. Each general switch can be specified
only once in a SUBMIT command. You can put a switch anywhere in the
command string.
/AFTER:hh:mm

Switch

If you do not want Batch to run your job until after a certain time or
until after a certain number of minutes have elapsed since the job was
entered, you can include the /AFTER switch in the SUBMIT command
string.
To run the job after a specified time of the day, you must
specify the time in the form hh:mm (for example, /AFTER:12:00 to run a
job after noon).
To run the job after a given amount of time has
elapsed, specify the time in the form
+hh:mm
(for
example,
/AFTER:+l:OO to run the job an hour from now). If you omit the
switch, Batch will schedule your job as it normally would using its
defaults.
If you omit the colon and/or value, the monitor will
respond with an error message and terminate the SUBMIT command.
/PAGE:n

Switch

Normally, Batch allows your job to print up to 200 pages. Included in
this number are the log file and any compilation listings that you may
request. If you need more than 200 pages for your job, you must
include the /PAGE switch in the SUBMIT command to indicate the
approximate number of pages that your job will print. If you include
the switch without the colon and a value, the monitor will assume that
you will print up to 2000 pages. If your output exceeds the number
that you specified in the /PAGE switch, the excess output will be lost
and the message ?LPTPLE Page Limit Exceeded
will
be
printed.
However, even if you exceed the maximum, the first 10 pages of the log
file will be printed.
/TIME:hh:mm:ss

Switch

Normally, Batch allows your job to use up to five minutes of central
processor time.
Central processor (CPU) time is the amount of time
that your job runs, not the amount of time that it takes Batch to
process your job. If you need more than five minutes of CPU time, you
must include the /TIME switch in the SUBMIT command to indicate the
approximate amount of time that you will need. If you specify the
switch without the colon and a value, Batch will assume that you need
one hour of CPU time. If you do not specify enough time, Batch will
terminate your job wh!n the time is up.
The value in the /TIME switch is given in the form hh:mm:ss
(hours:minute5:seconds).
If you specify only one number, Batch
assumes that you mean seconds. Two numbers separated by a colon are
assumed to mean minutes and seconds. All three numbers, separated by
colons, mean hours, minutes, and seconds. For example:
/TIME:25
/TlME:l:25
/TlME:l:25:00

means 25 seconds
means 1 minute and 25 seconds
means 1 hour and 25 minutes and no seconds

2-6

ENTERING A BATCH JOB FROM A TERMINAL
2.2.2

File-Control Switches

File-control switches allow you to specify parameters for
individual
files
ln the SUBMIT command.
The control file can receive a special
parameter, while the log file does not, and vice versa.
If you place
a
file-control switch before the two filenames in the SUBMIT command,
the switch applies to both files in the request.
If you place
the
switch after one of the files in the command, it refers only to that
file.
The switches, and the assumptions made if they or
their
values are
omitted,
are all subject to change by each installation.
Check with
the installation where you run your jobs to find out what differences
exist between the values described here and those at the installation.
Additional switches available for use with
the SUBMIT command are
defined
in the DECsystem-lO (TOPS-lO) Batch Reference Manual and the
DECsystem-lO (TOPS-lO) Operating System Commands Manual.

2.2.3

Examples of Submitting Jobs

The following are sample jobs entered to Batch by means of the
command.

SUBMIT

Example 1:
This control
file consists of commands
program, print a listing, and execute it.

compile

FORTRAN

GO
• SOS MYFILE .CTLG~
INPUT:
MYFILE.CTL
00100
.COMF'ILE MYF'ROG.FOR/LIST/COMPILE~
00200
.EXECUTE MYF'ROG.FOR~
00300
$

(DSKC:MYFILE.CTLJ

After the control filE! to compile and execute the FORTRAN program
has been created and saved, you must submit the job to Batch.

.SUBMIT·MYFILE.CTL~
When the monitor
following:

reads

this

SUBMIT

command,

assumes

the

your

The control filename and type are MYFILE.CTL.

The name of the job is MYFILE.

The log file will be named MYFILE.LOG.

Both the control file and the log file will be saved in
disk area.

2-7

ENTERING A BATCH JOB FROM A TERMINAL
5.

200 is the maximum number of pages to be printed (/PAGE:200).

The maximum amount of CPU time is 5 minutes (/TIME:5:00).

Example 2:
The next example shows the control file that was created
beginning of this chapter being submitte' to Batch.

the

After you have saved the control file, you can submit the job
Batch.

G:)

• TYf'E'MYFILE.CTL~

00100
00200
00300
00400

.COMf'ILE
.EXECUTE
.COHPILE
.EXECUTE

MYf'ROG.FOR/COMPILE
MYPROG.FOR
PROG2.FOR/COMPILE
PROG2.FOR

.SUBMIT+MYJOB:::MYFILE/TIME:20/PAGE:750/AFTER:10:00~
When the monitor reads this request, it assumes the following:
1.

The name of the job is MYJOB.

The name of the control file is MYFILE.CTL.

The log file will be named MYFILE.LOG.

The log file will be left in
printed.

The control file will be left in your disk area.

750 is the maximum
(/PAGE: 750) .

that

can

printed

The maximum amount of CPU time that the job
seconds (/TIME:20).

can

use

The job will be processed only after 10:00 A.M.

number

your

disk

pages

area

after

If you made an error in the SUBMIT command when you submitted either
of these jobs, the monitor will type an error message on your terminal
to explain your error so that you can correct it.

2.3

BATCH COMMANDS

You can write certain Batch commands in the control file to tell Batch
how to process your control file.
Each of these commands must be
preceded by a period (.) so that Batch will recognize it.
The most
commonly used Batch commands are described in the following sections,
but not all Batch commands are described here. For a description of
all commands, refer to the DECsystem-lO (TOPS-lO) Batch Reference
Manual.

2-8

ENTERING A BATCH JOB FROM A TERMINAL
2.3.1

The .IF Command

You can include the .IF command in your control
file
to specify an
error-recovery procedure to Batch or to specify normal processing if
an error does not occur.
The .IF statement has the forms:
.IF

(ERROR) statement

(The parentheses must be included.)

.IF

(NOERROR)

(The parentheses must be included.)

statement

where
statement

is a command to the system, to a
Batch ..

An example of the .IF

program,

(ERROR) command follows:

!DO A DIRECTORY IF AN ERROR OCCURS
.IF (ERROR) .DIRECT/ALLOC

An example of the .IF

(NOERROR) command follows:

!IF NO ERROR OCCURS, GIVE A SECOND LINE OF INPUT
.IF (NOERROR) *FILE.SCM=A.TXT,B.TXT
The .IF command can be used in two ways as shown in its two forms.
You can include the .IF (ERROR) command in your control file at the
place where you suspect an error may occur.
The .IF
(ERROR)
command
must be the next command in your control file (that is, the next line
which begins with a period
(.» after an error occurs; otherwise,
Batch will terminate your job.
In the .IF (ERROR) command, you direct
Batch to either go back or forward in your control file to find a line
that will perform some task for you or that will direct the system or
any other program to perform some task for you.
You can use the .IF (NOERROR) command to direct Batch or the system to
perform tasks
for
you when an error does not occur at the point in
your control file where you place the .IF (NOERROR) command.
Thus, if
you expect that an error will occur in your program, you can include
an .IF (NOERROR) command to direct Batch in case the error does not
occur,
and
then put the error-processing lines immediately following
the command.
Refer to Section 2.4 for
more examples of using
.IF
(NOERROR) and .IF (ERROR).
If an error occurs and Batch does not find an .IF command as the
command line in the control file, Batch terminates the job.

2.3.2

The .ERROR Command

With the .ERROR command, you can specify to Batch the character
that
you wish
to be recognized as
the beginning of an error message.
Normally, when Batch reads a message that begins with a question mark
(?),
it assumes a
fatal
error has occurred and terminates the job
unless you have specified error recovery (refer to Section 2.4).
If
you wish Batch to
recognize another character (in addition to the
question mark) as the beginning of a fatal
error message,
you must
specify the character in the .ERROR command.
The character specified
may not be a control character,
an exclamation point
(!)
or
a
semicolon(;).
The exclamation point
is always interpreted as the
2-9

ENTERING A BATCH JOB FROM A TERMINAL
comment character and will not function as the error-signal character.
This command has the form:
.ERROR character
where
character

is a single ASCII character

If you do not specify a character in the .ERROR command, Batch uses
only the standard error character, the question mark. When a line
that begins with the character you specify in the .ERROR command is
output to the Batch job by the syatem, a system program, or is issued
by Batch itself, Batch treats the line as a fatal error and terminates
the job, exactly as it would if the line were preceded by a question
mark.
Any messages preceded by other characters will not
be
recognized by Batch as errors.
If you do not include the .ERROR command in your control file, Batch
will recognize only the question mark as the beginning character of a
fatal error message.
An example of the .ERROR command follows •

• ERROR %

• ERROR
In this example, you specify in the middle of the control file that
you want Batch to recognize the question mark (?) and the percent sign
(%) as the beginning character of a fatal error from that point in the
control file.
Further on in the control file, you tell Batch to go
back to recognizing only the question mark as the beginning of a fatal
error message.

2.3.3

The .NOERROR Command

You can use the .NOERROR command to tell Batch to ignore all error
messages issued by the system, system programs, and Batch itself. The
.NOERROR command has the form:
. NOERROR
When Batch reads the .NOERROR command, it ignores any error messages
that would normally cause it to terminate your job.
The only
exception is the message ?TIME LIMIT EXCEEDED.
Batch will always
recognize this as an error message, give you an extra 10% of your
allotted time, and terminate your job.
You can use .NOERROR commands in conjunction with .ERROR commands in
the control file to control error reporting. For example, if you wish
to ignore errors at the beginning and end but not in the middle of the
control file, place .ERRQ~ and .NOERROR commands at the appropriate
places in the control file. In addition, you can also specify which
messages must be treated as fatal errors.

2-10

ENTERING A BATCH JOB FROM A TERMINAL

. NOERROR

.ERROR %

• ERROR

• NOERROR
The first command tells Batch to ignore all errors in your job.
The
second command tells Batch to recognize as errors any message that
starts with a question mark (?) or a percent sign (%). You change the
error reporting with the next command to tell Batch to go back to
recognizing only messages that begin with a question mark as fatal.
The second .NOERROR command tells Batch to ignore all error messages
again. If the ?TIME LIMIT EXCEEDED message is issued at any time,
Batch will print the message, extend the time by 10%, and then
terminate the job.

2.3.4

The .GOTO Command

You can include the .GOTO command in your control file to direct Batch
to skip over lines in the control file to find a specific line. The
.GOTO command has the form:
.GOTO label
where
label

is a one- to six-character alphanumeric label for a
statement.
The line that contains the label must be
followed by two colons (::).

An example of the .GOTO command follows •

. GOTO ABC

ABC::.DIRECT
You can use the .GOTO command as the statement in an
(refer to Section 2.3.1) to aid you in error processing.

.IF (ERROR) .GOTO ABC

ABC::.TYPE MYPROG
2-11

.IF command
For example:

ENTERING A BATCH JOB FROM A TERMINAL
When Batch encounters a .GOTO command in the control file, it searches
forward in the control file to find the label specified in the .GOTO
command.
Batch then resumes processing of the control file at the
line which has the specified label.
If the label is not found, Batch
will issue the message
? BTNCNF Could not find label xxxxxx
and the job will be terminated.
If you do not include a .GOTO command in the control file, Batch reads
the control file sequentially from the first statement to the last.

2.3.5

The .BACKTO Command

You can use the .BACKTO command to direct Batch to search back in the
control file for a line with a specified label. The .BACKTO command
has the form:
.BACKTO label
where
label

is a one- to six-character alphanumeric label for
a
statement.
The line that contains the label must be
followed by two colons (::).

An example of the .BACKTO command follows.

ABC::.DIRECT

.BACKTO ABC
Normally, Batch reads the control file line by line and passes the
commands and data to the system and your program. When you put a
.BACKTO command into the control file, you tell Batch to interrupt the
normal reading sequence and to search back in the control file to find
a line containing the label specified in the
.BACKTO command.
The
.BACKTO command searches for the label you specified, starting from
the beginning of the file and ending at the place the command was
given.
When the labeled line is reached, Batch executes the line and
continues from that point.
If Batch cannot find the labeled line, it terminates your job.

2.4

SPECIFYING ERROR RECOVERY IN THE CONTROL FILE

If you do not specify error recovery when an error occurs in your job,
Batch terminates the
job.
You can specify error recovery in the
control file by means of the Batch commands, especially the .IF Batch
command.
If you wish to recover from errors while the job is
processing, you must put the .IF command at the point between programs
in the control file where an error may occur. When an error occurs,
Batch skips over all lines in the control file until it encounters a
line beginning with a period
(.).
If this line contains an .IF
2-12

ENTERING A BATCH JOB FROM A TERMINAL
command, the .IF command is processed and the job continues.
If this
line does not contain an
.IF command,
the
job is terminated.
Therefore, if a Batch job is to recover from an error successfully,
the
.IF command must be placed in the control file where the error is
expected to occur but before any other commands preceded by the
character. Thus, if you have a program that you are not sure is error
free, you can include an .IF command to tell Batch what to do if an
error occurs, as shown in the following example .
. COMPILE MYPROG.FOR
.IF (ERROR) statement

In either the .IF (ERROR) or the .IF
(NOERROR)
command,
you should
include a statement that tells Batch what to do.
You can use any
monitor command or Batch command.
The .GOTO and .BACKTO commands are
also commonly used for
this purpose.
Refer to Sections 2.3.4 and
2.3.5 for descriptions of these commands.
Be sure, if you use
.GOTO
or
.BACKTO in the .IF command, that you supply a line in the control
file that has the label that you specified in the
.GOTO or
.BACKTO
command.
If you wish to simply ignore the error without taking any
special action, you may use a comment as the statement.
Two sample jobs are shown below. The first shows the
.IF
(ERROR)
command and the .GOTO command to specify error recovery.
The second
example shows the use of the .IF (NOERROR) and .GOTO commands.
If you have a program that you are not sure will compile without
errors,
you can include another version of the same program in your
job (that hopefully will compile) and tell Batch to compile the second
program if the first has an error.
You would write the control file
as follows.
~

.sos MYFILE.CTL~
INPUT:
00100
00200
00300
00400
00500
00600
00700
00800
00900

MYFILE.CTL
.COMF~ILE /COMF'ILE MYF'ROG.FOR/LIST~
• IF (ERROR) • GO TO A QB
• EXECUTE MYF'ROG. FOR QB
• GOTO B ~
A::!CONTINUE0~

.COMF'ILE /COMPILE PROG2.FOR/LIST~
.EXECUTE PROG2.FORG!I)
B::!CONTINUEC~
$

(ED

[DSKC:MYFILE.CTLJ

When the job is run, Batch reads the control file and passes commands
to the system.
If an error occurs in the compilation of the first
program, Batch finds the .IF (ERROR) command and executes the
.GOTO
command contained in it. The .GOTO command tells Batch to look for
the line labeled A::.
Thus, Batch skips lines in the control file
until it finds label A and then passes commands to the batch job from
that point.
If an error does not occur while compiling MYPROG,
the
.GOTO A statement is not executed.
Instead, MYPROG is executed and
then Batch skips to the line labeled B::.
2-13

ENTERING A BATCH JOB FROM A TERMINAL
A variation of the above procedure is shown below using the .IF
(NOERROR) command and the .GOTO command. The difference is that Batch
skips the .IF (NOERROR) command if an error does occur, and performs
it if an error does not occur. The following is the control file that
you would create.
GQ

.SOS MYFILE.CTL~
INPUT:
MYFILE.CTL
00100
.COMPILE ICOMF'ILE MYF'ROG.FOR/LIST~
00200
.IF (NOERROR) .GOTO A~
00300
.COMf'ILE ICOMF'ILE F'ROG2.FOR/LIST~
00400
• EXECUTE F'ROG2. FOr:;: ~
00500
.GOTO B~
00600
A::!CONTINUE~
00700
• EXECUTE MYPROG. FOR ~
00800
B: : ! CONT I NUE GIQ
00900
$

[DSKC:MYFILE.CTLJ

When the job is run, Batch passes the COMPILE command to the system to
compile the first program.
If an error does not occur, the .IF
(NOERROR) command and the .GOTO command are executed, Batch skips to
the line labeled A, which is a comment, and passes commands to the
Batch job from that point. The program MYPROG.FOR is executed and the
end'of the job is reached. If an error occurs while compiling MYPROG,
Batch skips the .IF (NOERROR) command and continues reading the
control file. PROG2.FOR is compiled and then executed. Batch is then
told to go to the line labeled B, which is a comment line. The end of
tpe job follows.
The examples shown above illustrate only two ways that you can use the
.IF commands to specify error recovery in the control file. You can
use any of the Batch commands or any system command that you wish to
recover from errors in your job.
However,
job is
messages
run your

you do not have to attempt to recover from errors while your
running.
You can correct your errors according to the error
in the log file when your job is returned to you, and then
job again. The log file is described in Chapter 4.

2-14

CHAPTER 3
ENTERING A BATCH JOB FROM CARDS

When you enter a job to Batch from card input, you must create a
control file on cards that is somewhat similar to a control file
created on a timesharing terminal, but that contains some additional
Batch commands.
The card control file must tell Batch to start your
job, the tasks or steps your job must take, and when to stop your
Batch job. The tasks or steps in your Batch job can consist of calls
to a system program, can create files on disk, and can recover from
errors.
Your control card input to Batch may contain any combination
commands. These commands are in four groups as follows:

TOPS-IO system commands, which consist of commands in a
format similar to what you would ~ssue for the same command
on a timesharing terminal. Examples of these commands are
.COPY, .DISMOUNT, .PRINT, and .RENAME.

System program commands, which consist of commands that
pertain to a system or user program. An example is the
command to the FILCOM program to specify files to be
compared.

Batch commands, as described in Chaptc;r 2, Section 2.3.

Batch control card commands, some of which are listed below.
$JOB
$PASSWORD
$EOJ
$CREATE
$-language
$EXECUTE
$DATA
$EOD
$TOPSIO
$ERROR
$NOERROR

(See Section
(See Section
(See Section
(See Section
(See Section
(See Section
(See Section
(See Section
(See Section
(See Section
(See Section

3.2.1)
3.2.2)
3.2.3)
3.2.4)
3.2.5)
3.2.6)
3.2.7)
3.2.8)
3.2.9)
3.2.10)
3.2.10)

Not all of the available Batch control commands are listed
above
and
described
in
Section 3.2.
Refer to the
DECsystem-lO (TOPS-IO) Batch Reference Manual for a complete
description of all available Batch control card commands.

3-1

ENTERING A BATCH JOB FROM CARDS
3.1

BATCH CONTROL CARD FORMAT CONVENTIONS

The Batch control cards must contain a dollar sign ($) in column 1 and
a command that starts in column 2. The command must be followed by at
least one space, which can then be followed by other
information.
(Refer to the individual description of each card for more information
about it.)
A card with a TOPS-10 system command must contain a period
(.)
in
column 1 followed
immediately by the command.
Any information that
follows the command is in the format shown for
the command in the
DECsystem-10
(TOPS-10) Operating System Commands Manual. The $TOPS10
Batch control card command must precede TOPS-10 system commands in
your
card deck.
(Refer to Section 3.2.9 for
the format and
description of the $TOPS10 card.)
A card with a command to a system program must contain an asterisk
in column 1 followed immediately by the command string.

(*)

Batch commands are formatted in the same manner as system commands;
that is,
a period
(.)
is punched in column 1 and the command
immediately follows it.
You must also place a
$TOPS10 card before
Batch commands in the card deck to enable execution of these commands.
If you put any special characters other than those described above in
the first column of a card, you may get unexpected results because
Batch interprets other special characters in special ways.
If you have more information than will fit on
hyphen
(-)
as the last nonspace character
continue the information on the second card.

one card,
insert a
on the first card and

Comments can also be included either on separate cards or on cards
containing other
information.
If the entire card is to contain a
comment, the card should contain a dollar sign ($) in column 1 and an
exclamation point
(!)
in column 2.
The exclamation point (!) is
called the comment character.
If the card contains a command followed
by a comment,
only the exclamation point
(!) should precede the
comment.
If the comment is too long to be contained on a single card,
begin the next card with a dollar sign
($) in column 1 and the
exclamation point (!) in column 2 and then continue the comment.
Refer
to the manual that describes the program you are using, as some
programs and their input do not accept comments preceded by the
exclamation point (!).

3.2

BATCH CONTROL CARD COMMANDS

Eleven Batch control card commands are described in the following
sections.
Additional Batch control card commands are available and
can be referred to in the DECsystem-10
(TOPS-10)
Batch Reference
Manual.

3.2.1

Starting a Job - The $JOB Card

The $JOB card is the first card in your card deck.
The $JOB card
tells Batch whose
job it is processing and, optionally, the name of
the job, and any constraints that you want to place on the job.
When
Batch reads the $JOB card, it begins the log file for your job.

3-2

ENTERING A BATCH JOB FROM CARDS
The $JOB card has the form:

$JOB jobname [proj,progj

[proj , prog.1

is the project-programmer number assigned to you
by the installation to allow you to gain access to
the DECsystem-10.
The project~programmer number
(PPN)
must be enclosed in either square brackets
([ ]), parentheses (( )), or angle brackets « ».
Square brackets can be obtained with a ¢ sign for
the left bracket and a
!
sign for
the right
bracket.
Refer to Appendix B of the Hardware
Reference Manual for a description of several
kinds of keypunches~

/switches

are optional switches to Batch to tell it the
constraints that you have placed on your job.
They are described below.
/AFTER:dd-mmm-yy

hh:mm

Switch

If you do not want Batch to run your job until after a certain time
and/or a certain day, you can include the /AFTER switch on your $JOB
card. The date and time are specified in the form dd-mmm-yy hh:mm
(e.g.,
16-APR-78 17:15).
If you omit this switch, Batch schedules
your job as it normally does;
that is, Batch schedules your job based
on the time required and other parameters.
/AFTER:+hh:mm

Switch

If you do not want Batch to run your job until after a certain amount
of time has elapsed since the job was entered, include this form of
the /AFTER switch on the $JOB card. The amount of time that the
job
must wait after
it has been entered is specified in the form +hh:mm
(e.g., +1:30).
If this switch is not included,
Batch will schedule
the job as it normally does.
/PAGES:n

Switch

ENTERING A BATCH JOB FROM CARDS
message ?LPTPLE Page Limit Exceeded will be written in the log file.
However, even if you exceed the maximum, the first 10 pages of the log
file will be printed.
NOTE
Do not arbitrarily enter a
large PAGES
value as this may delay execution of
your Batch job.

/TIME:hh:mm:ss

Switch

Normally, Batch allows your job to use up to five minutes of central
processor
(CPU)
time.
CPU time is the amount of time that your job
runs in memory, not the amount of time that it takes Batch to process
your
job.
Lf you need more than five minutes of CPU time, you must
include the /TIME switch on the $JOB card to indicate the approximate
amount of time that you will need.
If you do not specify enough time,
Batch will terminate your job when the time is up.
However,
if you
specify a
large amount of time, Batch may hold your job in the queue
until it can schedule a large amount of time for it.
The value in the /TIME switch is given in the form hh:mm:ss
(hours:minutes:seconds).
If you specify only one number,
Batch
assumes that you mean seconds.
Two numbers separated by a colon
(:)
are assumed to mean minutes and seconds.
All three numbers separated
by colons mean hours, minutes, and seconds.
For example:
/TIME:25
/TIME:l:25
/TIME:l:25:00

means 25 seconds
means 1 minute and 25 seconds
means 1 hour, 25 minutes, and no seconds

The following rules apply to all switches in
require a time and/or date to be specified:

the

above

list

that

When you specify the time of day (hh:mm:ss)
1.

You must not omit the colon

When you specify a date

<:) or colons.

(dd-mmm-yy)

You must not omit the hyphens.

You must specify both the day and
requirement.

You can abbreviate the month to a minimum of
e.g., JUL for July.

If you omit the year, the current year will be used.

If you omit the time from a date specification, the time is
assumed to be midnight on the specified date.
In the example
below a current date and time of
20 April, 1978,
lOAM will
be assumed.
/AFTER:18:00
/AFTER:3-May
/AFTER:19-Apr 20:00

the

month

three

minimum
letters,

means 6 P.M. on April 20, 1978
means midnight on May 3, 1978
means 8 P.M on April 19, 1978

3-4

ENTERING A BATCH JOB FROM CARDS
3.2.2

Identifying Yourself - The $PASSWORD Card

You put the password that has been assigned to you on the $PASSWORD
card to tell Batch that you are an authorized user of the system.
In conjunction with the $JOB card, the $PASSWORD card identifies you
to Batch and tells Batch to process your job. If you put a password
on the $PASSWORD card that does not match the password stored in the
system for you, Batch will terminate your job. The $PASSWORD card
must be present and must immediately follow the $JOB card.
The $PASSWORD card has the form:

$PASSWORD password

password

3.2.3

is a 1- to 6-character password that is stored in
the system to identify you. There must be exactly
one space between the end of the
card
name
($PASSWORD)
and
the
first character of your
password.

Ending a Job - The $EOJ Card"

You must put the $EOJ card at the end of the deck containing your
complete job to tell Batch that it has reached the end of your job.
If you omit the $EOJ card, an error message will be issued.
However,
your job will still be scheduled and may be processed if another job
follows it. The form of the $EOJ card is shown below.

$EOJ

3.2.4

Creating a File - The $CREATE Card

You can put the $CREATE card in front of any program, data,
set
of information to make Batch copy the program,
information into a disk file.
If the appropriate switch is
Batch will also print this file on the line printer.
3-5

or other
data, or
included,

ENTERING A BATCH JOB FROM CARDS
The form of the $CREATE card is:

$eR EATE filename.ext/switches

filename.ext

specifies the optional
filename
and
file
extension you want Batch to put on the file it
creates for your program or data.
If you omit
the filename and extension, Batch will create a
unique name for your file of the form CRxxxx,
where xxxx represents a unique name generated by
Batch.

/switches

are switches to Batch to tell it how to read the
cards in your deck.
The switches are described
below.
/WIDTH:n

Switch

Normally, Batch reads 80 columns on every card in your deck.
You can
make Batch stop reading at a specific column by means of the /WIDTH
switch, where you indicate the number of the column at which to stop.
Thus,
if you have no information in the last 10 columns of each card
in your deck, you can tell Batch to read only up to column 70 by
specifying
/WIDTH:70
/SUPPRESS

Switch

When Batch reads the cards in your deck, it normally copies everything
on the card up to column 80 (or up to any column you may specify with
the /WIDTH switch).
However, if you do not want trailing spaces
copied
(to save space on the disk, for example), you can tell Batch,
by means of the /SUPPRESS switch, not to copy any trailing spaces into
the disk file.
/PRINT

Switch

The file currently being created on disk by Batch
line printer.

3-6

listed

the

ENTERING A BATCH JOB FROM CARDS
Examples
The simplest form of the $CREATE card is:
$CREATE
This card causes Batch to copy your deck into a disk file and to
assign a unique name to it. All 80 columns of the cards are read and
trailing spaces are copied into the file. The file is not printed.
The following is an example of a $CREATE card.
$CREATE MYFILE.CDS/WIDTH:50/PRINT
The deck that follows this card is copied into a disk file named
When Batch reads the cards in the deck, it copies
MYFILE.CDS.
trailing spaces into the file, reading up to 50 columns.
The disk
file created from your cards will be printed on the line printer.

Compiling a Program - The $-language Card

3.2.5

The $-language card specifies the source program language of your
program on cards.
It is placed in front of your program. The
$-language card may be any of the follow~ng:
1.

$COBOL

$FORTRAN

$MACRO

$ALGOL

The $-language card causes Batch to copy your source program into a
disk file and compile it. You may then execute your program by using
the $EXECUTE card (Section 3 . 2.6) or the $DATA card (Section 3.2.7).
Optional information (/switches) may be included on the $-language
card to tell Batch how to read and compile your program.
When Batch copies your source program file onto disk, Batch assigns a
unique filename for your program in the form of LNxxxx. Depending on
the type of $-language card, the appropriate file extension is also
assigned to this file. When your Batch job completes, the LNxxxx file
is deleted automatically.

3-7

ENTERING A BATCH JOB FROM CARDS
The $-language card has any of the following forms:

"
SALGOLIswitches

SCOBOLIswitches

SFORTRAN/switches

SMACRO/switches

/switches

are switches to Batch to tell it how to read your
program
and
whether
or
not to request a
compilation listing when the program is compiled.
The switches can be put on the card in any order.
The following three switches may be used with any
of the $-language cards. Additional switches are
available
and
can
be
referenced
.in
the
DECsystem-10 (TOPS-IO) Batch Reference Manual.
/WIDTH:n

Switch

Normally, Batch reads up to 80 columns on every card of the source
program.
You can make Batch stop reading at a specific column by
means of the /WIDTH switch. You indicate the number of a column at
which to stop. Thus, if you have no useful information in the last 10
columns of each card of your program, you can tell Batch to read only
up to column 70 by specifying
/WIDTH:70
/NOLIST

Switch

Normally, the $-language card tells Batch to ask the compiler to
generate a compilation listing of your source program. The listing is
then printed as part of your job's output. If you do not want this
listing, you can include the /NOLIST switch on the $-language card to
stop generation of the listing.

3-8

ENTERING A BATCH JOB FROM CARDS
/SUPPRESS

Switch

When Batch reads the cards of your source program it normally copies
everything on the card up to column 80 or any column you may specify
with the /WIDTH switch.
However, if you do not want trailing spaces
copied
(to save space on the disk, for example), you can tell Batch,
by means of the /SUPPRESS switch, not to copy any trailing spaces into
the disk file.
Examples
The simplest form of the $-language card is
example using ALGOL.

shown

the

following

$ALGOL
This card causes Batch to copy your ALGOL card program into a disk
file.
The cards in the program are read up to column 80 and trailing
spaces are not suppressed.
A listing file
is produced when the
program is compiled.
The listing is written as part of the job's
output.
The following is an example of a $ALGOL card with switches.
$ALGOL/NOLIST/SUPPRESS/WIDTH:72
with this card, Batch copies your program onto disk and inserts a
COMPILE command into the control file.
When the program is compiled,
no listing is produced. The cards in the program are read up to
column 72, and trailing spaces up to column 72 are not copied into the
file.

3.2.6

Executing a Program - The $EXECUTE Card

The $EXECUTE card is used to execute the program that has been
compiled using the $-language card.
This card is used when the
program requires no data or uses data already existing on disk.
The
form of the $EXECUTE card is shown below.

SEXECUTE/switch

/switch

is a switch to Batch to tell it what to include
the command it inserts in the control file.

3-9

ENTERING A BATCH JOB FROM CARDS
/MAP

Switch

If you want a loader map to be generated and printed for you when your
program is run, you can specify the /MAP switch on the $EXECOTE card
to tell Batch to request one for you.
An $EXECUTE card following another $EXECUTE card in the control file
without any intervening $-language cards causes the program executed
by the first EXECUTE card to be loaded and executed again.

3.2.7

Executing a Program with Data - The $DATA Card

The $DATA card is used when you want to execute a program that uses
data 'from cards.
The $DATA card must be in front of the input data
cards. When Batch reads the $DATA card, Batch copies the data cards
that follow it onto a spooled card-reader file and then inserts an
EXECUTE command into your control file to execute y6ur program.
When your job is run, any programs are executed which were entered
with $-language cards that came before the $DATA card. The spooled
card reader file becomes the input to the currently executing program,
and your program may reference this file by using the card reader as
the input device.
If your input control file contains more than one program and input
data, Batch will execute the first program with the input data, spool
the results to be printed, and then compile the second program when
Batch reads the second $-language card. Again, when Batch reads the
second $DATA card, a spooled card-reader file 1S created for your
input data cards and an EXECUTE command is inserted in your control
file.
A $DATA card (with its associated card deck) followed by another $DATA
card (with its deck), without intervening $-language cards, causes the
program to be loaded and executed twice. The first deck is used as
data on the first execution and the second deck is used as data on the
second execution.
If your data is included in the program or is already on disk (so that
you do not have cards with data on them), use the $EXECUTE. card
(Section 3.2.6) to execute the program.
The form of the $DATA card is:

$OA T A fi lename,e xt/switches

3-10

ENTERING A BATCH JOB FROM CARDS
filename.ext

specifies an
optional
filename
and
file
extension for
the input data file (see Section
3.2.7.1).
If omitted, a spooled card-reader
file is created.
You may reference this file by
using the card reader as the input device in the
source program.
If included,
a disk file is
created, and you may reference this file by
using the disk as the input device.

/switches

are switches to Batch to tell
it how to read
your data cards.
The switches are described
below.
/WIDTH:n

Switch

Normally, Batch reads up to 80 columns on every
You can make Batch stop reading at a specific
/WIDTH switch, where you indicate the number of
stop.
Thus, if you have no useful information
of each card of your data, you can tell Batch
column 70 by specifying

card of your data.
column by means of the
a column at which to
in the last 10 columns
to read only up to

/WIDTH:70
/SUPPRESS

Switch

When Batch reads the cards of your data, it normally copies everything
on the card up to column 80 or .up to any column you may specify with
the /WIDTH switch. However, if you do not want trailing spaces copied
(to save space on the disk, for example), you can tell Batch, by means
of the /SUPPRESS switch, not to copy any trailing spaces into the disk
file.
/MAP

Switch

If you want a loader map to be generated and printed for you when your
program is run, you can specify the /MAP switch on the $DATA card to
tell Batch to request one for you.
Examples
The simplest form of the $DATA card is:
$DATA
This card causes Batch to copy your data into a spooled card-reader
file.
A spooled card-reader file is a file that Batch creates on disk
so that, when your program reads from the card reader,
that file
is
read.
All 80 columns of the cards are read and trailing spaces are
copied into the file.
The following example shows a $DATA card with switches.
$DATA MYDAT.DAT/WIDTH:72

3-11

ENTERING A BATCH JOB FROM CARDS
The data that follows this card is copied into a file named MYDAT.DAT
and an EXECUTE command is inserted into the control file.
When Batch
reads the cards of the data, it reads only up to column 72 and copies
trailing spaces into the data file.
To use the data in this file,
your program should reference file MYDAT.DAT on the disk.

3.2.7.1 Reading from a Spooled Card-Reader File - If you let Batch
assign a name to your data file, you will not know the name that your
data file will have: you should, therefore, assign your data file,
without a name, to the card reader. The following examples illustrate
how to do this.
NOTE
The $DATA card can be used for data of
programs
written
in
ALGOL, COBOL,
It can also be used
FORTRAN, and MACRO.
for programs that are in relocatable
binary form.
However, data for BASIC
programs cannot be copied by means of
the $DATA card because BASIC programs
are not compiled and executed.
For
BASIC programs, use the $CREATE card as
described in Section 3.2.4.
COBOL

Example

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
SELECT SALES, ASSIGN TO CDR.

DATA DIVISION.
FILE SECTION.
FD SALES, LABEL RECORDS ARE OMITTED.

$DATA (in the control file)

3-12

ENTERING A BATCH JOB FROM CARDS
FORTRAN

Example

To read your data from the card reader, you use the unit number
no unit number, as shown below.
$FORTRAN

READ ( 2 , f), 1 is t

END
$DATA

$FORTRAN

READ f, list

END
$DATA

3-13

ENTERING A BATCH JOB FROM CARDS
ALGOL

Example

In an ALGOL program, you assign the desired channel (signified by c)
to the card reader and select the desired channel. Do not explicitly
open the named file on the channel because the file does not have a
name that is known to you.

INPUT (c, "CDR")
S.ELECT INPUT (c)

$DATA

3.2.7.2 Naming Data Files on the $DATA Card - If you want to name
your data file on the $DATA card rather than letting Batch name it for
you, you must, in your program, assign that file to disk as shown in
the following examples.
COBOL

Example

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
SELECT SALES, ASSIGN TO DSR.

DATA DIVISION.
FILE SECTION.
FD SALES, VALUE OF IDENTIFICATION IS "SALES CDS".

The $DATA card would then appear as follows.
$DATA SALES.CDS

3-14

ENTERING A BATCH JOB FROM CARDS
FORTRAN

Examples

You can assign your data to disk in several ways when you use FORTRAN.
You can read from unit 1, which is the disk, in your program and use
the name FOROl.DAT as the filename on your $DATA card, as shown in the
following statem~nts.

READ (1, f), list

$DATA FOROl.OAT
You can also tell FORTRAN to read from logical unit 2, which is
normally the card reader, and assign unit 2 or the card reader (CDR)
to disk (OSK). You can use the name FOR02.DAT on the $DATA card in
this case.

OPEN (UNIT=2,DEVICE='DSK')
READ (2,£), list

$TOPSlO
.ASSIGN DSK CDR
$DATA FOR02.DAT
ALGOL

Example

To read your data from the disk in an ~LGOL program, you would use the
following statements.
You can asslgn your data to any channel
(signified by c) and you can give your data file any name as . long as
the name that you use in your program is the same as that put on the
$DATA card.

3-15

ENTERING A BATCH JOB PROM CARDS

INPUT (c, "DSK")
SELECT INPUT (c)
OPENFILE (c, "MYDAT.DAT")

$DATA MYDAT.DAT
This is done to ensure that your program finds your data in
file under the name that you have assigned to it.

3.2.8

the

disk

End of Data Input - The $EOD Card

The $EOD card terminates the card
$CREATE, $DATA, or $-language card.

input

that

was

preceded

The form of the $EOD card is:

$EOD

If the $EOD card does not follow the card input, Batch recognizes the
next card with a dollar sign ($) in column one as a new Batch command
and as the end of the card input; that is, an EOD card is assumed if
one is not present.

3.2.9

System Commands - The $TOPSIO Card

You can include system commands, commands to system or user programs,
and
Batch commands in your deck by inserting a $TOPSIO card
immediately before these commands. The $TOPSIO card directs Batch to
copy all cards following it into the Batch control file. Therefore, a
single system command or Batch command or a group of consecutive
system and/or Batch commands must be preceded by a $TOPSIO card. The
copying process is terminated by the next control card in the deck.

3-16

ENTERING A BATCH JOB FROM CARDS

The form of the $TOPSIO card is:

$TOPS10/switches

/switches

are switches to Batch to tell it how to
interpret your input.
/WIDTH:n

read

and

Switch

Normally, Batch reads up to 80 columns on every card of your system or
Batch commands. You can make Batch stop reading at a specific column
by using the /WIDTH switch, where you indicate the column number at
which Batch is to stop reading.
Thus, if you have no useful
information in the last 10 columns of each card, you can tell Batch to
read only up to column 70 by specifying
/WIDTH:70
/SUPPRESS

Switch

When Batch reads your cards, it normally copies everything on the card
up to column 80 or up to any column you may specify with the /WIDTH
switch. However, if you do not want trailing spaces copied (to save
space on the disk, for example), you can tell Batch, by means of the
/SUPPRESS switch, not to copy any trailing spaces into the disk file.
Figure 3-1 illustrates a sample
TOPS-IO commands.

Batch

3-17

input

card

deck

using

only

ENTERING A BATCH JOB FROM CARDS

Figure 3-1 Batch Card Deck Using TOPS-IO Commands

3.2.10

Error Recovery - The $ERROR and $NOERROR Cards

You can use the $ERROR card and the $NOERROR card to recover from
errors that may occur while your Batch job is running. If an error
occurs during your job (for example, a program fails to compile),
Batch will normally terminate your job.
However, if a $ERROR or
$NOERROR card is included in your card deck immediately after the
point at which the error occurs, Batch will proceed as indicated on
the $ERROR or $NOERROR card and will not terminate the job.

3-18

ENTERING A BATCH JOB FROM CARDS
The $ERROR card has the form:

$IERROR statement

The $NOERROR card has the form:

$NOERROR statement

statement

is a system command or a special Batch command
(for example, .GOTO or .BACKTO) such as you would
include following a $TOPSIO card.
The Batch
commands
are described in Section 2.3.
The
statement may also be a comment (begun with the
exclamation point(!)) if yo~ wish Batch to simply
ignore the error.

If an error occurs in your Batch job and the $ERROR card is then
encountered, the statement on the $ERROR card is executed and the job
continues. If the $ERROR card is encountered when an error has not
occurred, the card is ignored.
If an error occurs in your Batch job and the $NOERROR card is
encountered, no action will be taken, with the exception that Batch
will not terminate your job as it would have if the card had not been
found.
If the $NOERROR card is encountered when no error has
occurred, the statement on the $NOERROR card is executed.
The $ERROR card is equivalent to the Batch command .IF(ERROR).
The
$NOERROR card is equivalent to the Batch command .IF(NOERROR). See
Section 3.5 for examples of Batch jobs using the $ERROR and $NOERROR
cards.

3-19

ENTERING A BATCH JOB FROM CARDS
3.3

SETTING UP YOUR CARD DECK

Batch enters commands into the control file when you use certain
control cards.
Where you put these control cards in your card deck
determines their position in the control file. Batch reads your card
deck in sequential order, copying commands into the control file as
they or the special control cards are read. However, when Batch reads
a control card that tells it to copy a program or data into a disk
file, the disk file is created immediately, before the remainder of
the job is processed. Every succeeding card is copied until another
control card is read.
A Batch job can do almost anything a timesharing job can do.
If you
wish to perform complicated tasks, you may include system commands in
your deck to direct Batch to execute these tasks.
Section 3.4
describes the way to include system commands for the desired control.
The $JOB card, the $PASSWORD card, and the $EOJ card are required for
all jobs.
The $JOB card must be the first card in the deck and must
be immediately followed by the $PASSWORD card. The $EOJ card must be
the last card in the deck.
The control cards used to compile and execute programs written in
ALGOL, COBOL, FORTRAN, and MACRO are shown 1n Figure 3-2. The
following card deck does not apply to control card decks for BASIC.
Refer to Section 3.4.1 for information regarding BASIC.

seOJ

ALGOL source program

$PASSWORD password
$JOB [proj,prog]

NOTE:
For other languages use
$COBOL,
$FORTRAN,
$MACRO, etc.

Figure 3-2

Typical Program Card Deck

3-20

ENTERING J\ BATCH JOB FROM CARDS
The typical card deck shown in Figure 3-2 includes a language card
($ALGOL, $COBOL, etc.) immediately prior to the source program. This
language card informs Batch of the system program to be employed for
processing
(compiling) the succeeding cards. The $DATA card likewise
immediately precedes the data cards to inform Batch that
the
succeeding cards contain data for the program. The program is stored
on disk as a disk file.
The input data is stored on a spooled
card-reader file. The $DATA card causes Batch to execute the program,
using the data cards as input. The $EOJ card informs Batch that all
cards pertaining to the job have been entered. At this time Batch has
access to the program to be compiled and the data to be used by the
program;
it knows what compiler or assembler is to be used, and has
built a control file containing the EXECUTE command so' that the
program will be run.

3.4

PUTTING COMMANDS INTO THE CONTROL FILE FROM CARDS

Batch enters commands into the control file when you use certain
control cards such as $EXECUTE and $DATA. However, only a small
number of operations, such as compilation and execution of programs,
can be put into the control file using control cards. To perform
operations in your control file other than compilation or execution,
you must include commands in your card deck for Batch to copy into
your control file.
If you want to include Batch commands or system
commands in your card deck, you must insert a $TOPSlO card immediately
before these commands in your deck. The $TOPSIO card directs Batch to
copy all succeeding commands into the control file until the next
control card is encountered. The commands will later be executed by
Batch in the same order that they appear in your card deck.
For example, in order to compare two card decks and produce a list of
the differences, you could include the cards shown in Figure 3-3 in
your deck.

3-21

ENTERING A BATCH JOB FROM CARDS

SEOJ
*LPT:=FI LE.ONE.F I LE.TWO

STOPS 1D/switches

SPASSWORD password

Figure 3-3

Use of Control Cards to Compare Two Card Decks

The only system commands that you cannot use in a Batch job are ATTACH
and SET TIME.
Batch will send these commands to the monitor, the
monitor will give an error, and Batch will detect the error and
terminate your job.
Also, you should not use the LOGIN command in
your Batch job because you will get an error. Batch logs in your job
in accordance with your $JOB and $PASSWORD cards.

3-22

ENTERING A BATCH JOB FROM CARDS
3.4.1

Card Decks for Programs that Do Not Have Special Control Cards

By using system commands and the $CREATE control card, you can process
any program that does not have special control cards. You put a
$CREATE card in front of a program, data, or any other group of cards
to make Batch copy the cards into a disk file and, if you request, to
print the file on the line printer. The $CREATE card is described in
detail in Section 3.2.4. You put the $TOPSlO card in front of monitor
and Batch commands to cause Batch to copy these commands into the
control file.
The $TQPSlO card is described in detail in Section
3.2.9.
For example, a BASIC program does not have a specific control card.
To run a BASIC program under Batch from cards, you can_combine the
$CREATE card and the $TOPSlO card with system commands. You can also
use a $CREATE card to copy the data which a BASIC program will use.
The $DATA card cannot be used, because the $DATA card puts an EXECUTE
command into the control file, and BASIC does not use the EXECUTE
command to run. The $TOPSlO card causes Batch to copy the monitor
commands into the control file.
Figure 3-4 shows a card deck that enters a BASIC program
under Batch.

3-23

for

running

1--'--..-._- .-.... .-.. -.-.

. .- .

ENTERING A BATCH JOB FROM CARDS
~

-.--.~.-~-

SEOJ
·MONITOR
·RUN

°DSK MYPROG.8AS
·OLD
R BASIC
STOPS 1O/swltches

SEOD

BASIC source program
SCR EATE MYPROG.BAS
SPASSWO R D password

'----_.

__._ _
..

Figure 3-4

.... --

BASIC Program Card Deck with Integral Data

This BASIC program contains statements that read data from
FILE.ONE. You answer OLD to the BASIC question

disk

file

NEW OR OLDbecause the program file is on disk and can be retrieved by BASIC.
If your BASIC program reads data that is to be input from a terminal
during the running of the program, enter the data in the control file
so that it will be passed to your program by Batch. This is shown in
Figure 3-5.

3-24

ENTERING A BATCH JOB FROM CARDS

$EOJ
*MONITOR

*3,5,-9,1,8
*5,1,3,2,-7

* 1,2,3,2,-7
*RUN
*OSK:MYPROG.BAS
*OLO
.R BASIC
$TOPS10/switches

$CREATE MYPROG.BAS
$PASSWORD password
$JOB [proj,prog]

Figure 3-5

BASIC Program Card Deck with Provisions
for Terminal Data Input

You can use the same technique to enter programs written in any
language that does not have a specific control card provided that your
installation supports the language. Also, you can run system programs
under Batch using the same technique.

3-25

ENTERING A BATCH JOB FROM CARDS
3.5

SPECIFYING ERROR RECOVERY IN THE CONTROL FILE

Normally, when an error occurs in your job, Batch terminates the job.
However, you can specify recovery from errors in the control file by
means of the $ERROR and $NOERROR cards, described in Section 3.2.10.
You must include one of these cards at the point in the control file
where an error may occur. When an error occurs, Batch examines the
next system command level line (skipping over lines that contain data
or command strings of a system program)
to find an .IF
(ERROR)
statement or
.IF(NOERROR)
statement to tell it what to do about the
error.
If an error does not occur and an . IF
(ERROR)
statement is
present, the .IF (ERROR) statement is ignored.
If an error occurs and
an .IF(NOERROR) statement is present, the statement is ignored with
the exception that Batch does not terminate the job.
Thus, if you have a program that you are not sure is error free, you
can include a $ERROR or $NOERROR card to tell Batch what to do if an
error occurs, as shown in Figure 3-6.

$EOJ

$ERROR statement

$PASSWO R 0 password
$JOB [proj,prog]

' - - - - - - - - - - - . - - - - - - - - - - - - - - - -_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _--....J

Figure 3-6

Card Deck with Error Statement

3-26

ENTERING A BATCH JOB FROM CARDS
The above cards would cause Batch to make the following entries in the
control file .
. COMPIL .
. IF (ERROR) statement
On either the $ERROR or $NOERROR card, you must include a statement
that tells Batch what to do.
You can use any system command, a
command to a program, or one of the special Batch commands. The .GOTO
and
.BACKTO Batch commands are commonly used for this purpose.
Refer
to Sections 2.3.4 and 2.3.5 for descriptions of these commands.
If
you use .GOTO or .BACKTO on your $ERROR or $NOERROR card, be sure that
you supply a line for
the control file
that has the label you
specified in the .GOTO or .BACKTO command.
Two sample jobs are shown on the following pages. The first shows the
use of the $ERROR card and the
.GOTO command to specify error
recovery.
The second example shows the use of the $NOERROR card and
the .GOTO command.
If you have a program that may compile with errors,
you can include
another version of the same program in your job (that hopefully will
compile) and tell Batch to compile the second program if the first has
an error. The cards to enter this job are shown in Figure 3-7.

3-27

ENTERING A BATCH JOB FROM CARDS

$EOJ
B 'CONTINUE
$TOPS10
$EXECUTE

FORTRAN source program

A:'CONTINUE
.GOTO B
$TOPS10

$ERROR .GOTO A

FORTRAN source program

~_$_PA_S _WO_R_DP_as_sw_ord

______

$JOB [proj.prog]

~ ~l
__

1,1

i I

Figure 3-7

Card Deck with Error Recovery Program

3-28

ENTERING A BATCH JOB FROM CARDS
These cards set up the following control file for you •
. COMPIL /COMP/FIO DSK:LNxxxx.FOR/LIST
.IF(ERROR)
.GOTO A
.EXECUT /REL/MAP:LPT:MAP DSK:LNxxxx.REL
.GOTO B
A··
!CONTINUE
.COMPIL /COMP/FIO DSK:LNxxxx.FOR/LIST
.EXECUT DSK:LNxxxx.REL
B··

!CONTINUE
.DELETE DSK:LNxxxx.FOR,DSK:LNxxxx.REL,DSK:LNxxxx.FOR,DSK:LNxxxx.REL
The $FORTRAN card told Batch to copy the program into a disk file,
to
create a unique filename for the program in the form LNxxxx.FOR, and
to insert a COMPILE command into the control file.
The $ERROR card
told Batch to insert .IF (ERROR) .GOTO A into the control file.
The
data was copied into a disk file and an EXECUTE command was put into
the control file
because of the $DATA card.
The $TOPSIO card told
Batch to start copying cards into the control file, so Batch put the
next two lines into the control file.
The second $FORTRAN card told
Batch to copy the program into a disk file,
create another
unique
filename for
the program in the form LNxxxx.FOR, and put a COMPILE
command into the control file.
A $EXECUTE card was used instead of a
$DATA card because the data for the second program was already in a
file on disk.
The $TOPSIO card caused the next line to be put into
the control file.
When the job is started, Batch reads
the control file and passes
commands to the system.
If an error occurs in the compilation of the
first program,
Batch executes the
.GOTO command within the
.IF
statement.
The command tells Batch to skip to the line labeled A,
which contains a comment.
Batch then proceeds to the next line.
The
second program is compiled and executed with the data.
The next line
is a comment, so Batch continues to the end of the control file.
If
an error does not occur
in the first program, Batch skips the .IF
statement, executes the program with the data,
avoids the second
program by skipping to label B,
and continues to the end of the
control file.
A variation of the above procedure, using the $NOERROR card and
.GOTO
command is shown in Figure 3-8.
The difference is that Batch skips
the .IF statement if an error occurs and performs it if an error does
not occur.

3-29

ENTERING A BATCH JOB FROM CARDS

SEOJ

B: :!CONTINUE

A::!CONTINUE

data for program

$CREATE FORO.1.DAT

FORTRAN source program

$PASSWORD password
$JOB [proj,prog)

Figure 3-8

Card Deck Using GO TO Statement

3-30

ENTERING A BATCH JOB FROM CARDS
Batch reads the cards and puts the following commands into the control
file •
. COMPIL /COMP/FIO DSK:LNxxxx.FOR/LIST
.IF(NOERROR)
.GOTO A
.COMPIL /COMP/FIO DSK:LNxxxx.FOR/LIST
.EXECUT DSK:LNxxxx.REL
.GOTO B
A· •

!CONTINUE
.EXECUT DSK:LNxxxx.REL
B· •

!CONTINUE
.DELETE DSK:LNxxxx.FOR,DSK:LNxxxx.REL,DSK:LNxxxx.eOR,DSK:LNxxxx.REL
The $FORTRAN card tells Batch to copy the FORTRAN program into a file,
to create a
unique filename of the form LNxxxx.FOR, and to insert a
COMPILE command into the control file.
The $NOERROR card tells Batch
to insert an .IF command into the control file.
The second $FORTRAN card tells Batch to copy the second program into a
disk
file, to create a unique filename of the form LNxxxx.FOR, and to
insert another COMPILE command into the control file.
Instead of a
$DATA card, a $CREATE card is used to tell Batch to copy the data into
a disk file named FOROl.DAT.
The $DATA card is not used here because
it would have the names of both programs in its list for the EXECUTE
command generation, which would cause an error when the
job is run.
To tell Batch to start copying cards
into the control file, the
$TOPSlO card comes next.
Thus, Batch copies the next five cards
into
the control file.
When the job is run, Batch passes the COMPILE command to the system to
compile the first program.
If an error does not occur, the .IF
command is read and the .GOTO command is executed.
Batch skips to the
line labeled A, which is a comment, and continues reading the control
file.
The program LNxxxx"FOR is executed with the data, and
the end
of the
job is reached.
If an error occurs while compiling the first
program, Batch skips the
.IF statement and continues reading
the
control file.
The second program is compiled and then executed with
the data.
Batch is then told to go to the line labeled B, which is a
comment line.
The end of the
job follows.
The TOPS-IO .EXECUTE
command was used in this job rather
than
the
$EXECUTE card.
The
$EXECUTE card would have caused
the names of both programs to be
included in the .EXECUTE command which would have resulted in an error
when the job was run.
The examples shown above illustrate only two ways that you can specify
error
recovery in the control file.
You can use the .BACKTO command
or any system command that you choose to help you recover from errors
in your job.
However,
job is
messages
run your

you do not have to attempt to recover from errors while your
running.
You can correct your errors according to the error
in the log file when your job is returned to you,
and
then
job again.

3-31

CHAPTER 4
INTERPRETING YOUR PRINTED OUTPUT

You can receive three kinds of printed output from your Batch jobs:

4.1

Output that you request, i.e., the results of your job.

Output from Batch commands, i.e., the log file.

Output that is the result of actions by your job, Batch,
the
system,
or system programs.
Examples of this output are
compilation listings,
cross-reference listings,
and error
messages.

OUTPUT FROM YOUR JOB

If your job uses the PRINT command to print files on the line printer,
the files will be printed in listings separate from the log file.
The
printed output from each program will be preceded by two banner pages
containing your user name and other pertinent information.
Following
these pages are two header pages that contain the name of your output
file
in block letters;
the output follows these header pages.
Two
trailer pages follow your output;
they contain the same information
that is on the first two pages.
The header and trailer pages also
include three rows of numbers (read vertically from 001 to 132)
that
represent the character print positions on the line printer.
If your output is usually directed to the terminal, it will be printed
in the log file, not as a separate file.
In the sample output shown
in Section 4.4, the output from the program is
included
in the log
file because it was directed to the terminal rather than the line
printer.
Although this chapter deals mainly with printed output, you can have
output to any device that the installation supports, as long as the
installation allows you to use these devices.

4.2

BATCH OUTPUT

The output from Batch consists of a log file
that contains all
the
statements in the control file, commands sent to the system from Batch
for you, and the replies to the commands from the system and
from
system programs like the compilers.
Any error message sent from the
system or system program or from Batch itself is also written in the
log file.

4-1

INTERPRETING YOUR PRINTED OUTPUT
When your Batch card job is printed on the line printer, it will have
a unique filename of JBxxxx and a file type of .LOG. This file is
deleted automatically after it has printed.

4.3

OTHER PRINTED OUTPUT

Other output that you can get as a
result of action by your
job
includes compiler listings, cross-reference listings, and loader maps
for programs that were successfully loaded.
The compiler and cross-reference listings are those listings generated
by the compiler
if you request them.
When you enter your job from
cards, Batch requests compilation listing for you unless you specify
otherwise.
Cross-reference listings are generated for you only if you
specifically ask Batch for them.
When you enter your
job from a
terminal, you must request the listings in the COMPILE command.
Refer
to the DECsystem-10 (TOPS-10) Batch Reference Manual for the switches
(/CREF,
/MAP)
that are available to generate additional listings for
your Batch job.
If a fatal error occurs in a program in your
job and you have not
included an error
recovery command to Batch, Batch will not try to
recover from the error for you.
Instead,
it will write the error
message in the log file and terminate your job.

4.4

SAMPLE BATCH OUTPUT

Two sample jobs and their output are shown in the following sections.
The first shows a job entered from a terminal, the second shows a job
entered from cards. The log file is somewhat different for
the two
types of jobs.

4.4.1

Sample Output of a Job from a Terminal

The following example illustrates a job as it would be entered from
terminal.
You would first create the program as a file on disk.

.SOS~COBOL1.CBL~

Input: COBOL1.CBL
00100
IDENTIFICATION tIIVISION.GIQ
00200
PROGRAM'~' I [I. COBOL 1 .~
00300
ENVIRONMENT [lIVISIDN.GD
00400
[lATA [lIVISION.GIQ
00500
PROCE~[lURE [I I VI S I ON .G!D
00600
START .~
00700
DISPLAY "THIS IS TO SHOW SAMPLE OUTPUT FROM BATCH.-.GIQ
00800
DISPLAY -THEBE TWO LINES ARE OUTPUT FROM THE PROGRAM.·.~
00900
STOP RUN.~
01000
$

*EG!D
[DSKC:COBOL1.CBLJ

4-2

INTERPRETING YOUR PRINTED OUTPUT
Then you would make up a control file to compile and execute the COBOL
program.

OQ
.80S MYJOB.CTL@Q
Input: MYJOB.CTL
00100
.COMPIL.E C()BOL.l.CBL/L..IST~
00200
• EXECUTE C()BDL.l. CBL~
00300
$

GQ
lDSKC:MYJOB.CTL.J
You would then submit the job to Batch using the SUBMIT command.

.SUBMIT MYJOB.CTL~
lINP26:MYJOB=/8eu:4951/Time:0:OS:00J
When the job is run,
the
produced.
The following
line-printer spooler:

program
listing

is
is

listing
is
compiled and a
placed
in the queue of the

PRO G RAM
cue 0 u 1
COBOLt,CRL
OS-APR-7S 14,52
0001
0002
0003
0004
0005
0006
0007

ool>e
0009

00100
00200
00)00
00400
00500
00600
00700
00800
00900

IDENTIfICATION DIVISION.
PROGRAM-rD. ~YPROG.
ENVIRONMENT DIVISION.
DATA DIVISIUN.
PPOCEoURE DIVISION.
STAPT.
DISPLAY "THIS IS TO SHOW ,AMPuE OUTPUT FROM BATCH.".
DISPLAY "THESE Twn LINES ARE OUTPUT 'RO~ TH~ PPOGRAM,".
S'TUP PUN.

NO ERROPS DETECYr.O
The log file below is printed as your job's output.
The output from
the program is written in the log file because it is output to the
terminal and the log file simulates the terminal dialogue.
The log
file also contains some commands that Batch sent to the system for you
and some additional system information.
An annotated
log file
is
shown on the following page.
Note that each line in the log file is
preceded by the time of day when the line was written.
Following the
time
is a word
that describes what kind of information is on each
line.
Much of the information is system information and is described
in detail in the DECsystem-lO (TOPS-10) Batch Reference Manual.

4-3

INTERPRETING YOUR PRINTED OUTPUT
1!H421Z9 BAJOB
'5142129 BArtL
15142129 HArIL
15142129 aASU~
15 42
1~ 41
15 42
15 42
15 42
15 42
15 -12
15 42
15 42

29 MON'TR
29 MO~TP
30 USEP
35 IJSEFI
35 USER
36 MONTP
36 MONTP
38 IJSEP
50 MQNTR
15 42 50 MONTR
\5 42 50 MONTR
15 42 50 MONTP
15 42 50 USER
15 42 51 usER
115 42 51 USER
15 42 51 USER
t5 42 51 MONTR
15 12 51 MQNTP
15 42 51 MONTP
15 42 51 "1QNTP
15 ~2 52 usr.p
15 42 52 USER
15 42 54 MONTR
15 42 54 MClNTR
15 12 54 MONTR
15 42 54 MONTR

4.4.2

BATCeN vtr.ion 10)(2l07) runnino MyJOB .,qulnce 4951 In .tream 1
Input from nS~CIMYJeB.CTL[27,5107)
OutPut to OSKCIMYJQB.LOGt27,5107J
JOb paramlter.
Tlml.nOI05.00
U~1qutIVES
RI.tartiNO
uutputlLOG

.LOGIN 27/5107 IDErERISpeOLaALL/TIME.300/LUCATEI26/NAME,"8MOWN,E"
JOB 21
RK3A7A ~Ll0 SYS-l026 TTY510
[LGNJSP Oth.r job • • eme PPNI46J
01-Auo- 7 A
Tue
1542
•• COMPILE COBOLt.CSL/LIST
C080Ll [(,OBUL1,C SL]

CO'3QLI

EXIT
•• EXECUTE COSOL1,CBL
LINl(.
t"oad1nIJ
tLNKXCT CO~OLI Execution]
THIS IS TO SHOW SAMPLE OUTPUT fROM BATCH.
THESE TWO LINES ARE OUTPUT FROM THE P~OG~AM.
EXIT

,I<JOB/BATCH
[t"GTAJL Another job 1 • • till lOOQ.d-1n under t27,5107JJ
JOb 23 U•• r BPDWN,g t27,5107]
LoOqed-off TTY510 at 15142.54
On l-AUQ-78
Punt1~el 010010\, KCS'22, Canneet time. 0.00.24
Dl,K ~.ad'1954, wrlt ••• 93

Sample Output of a Job on Cards

This example shows a job in which a small COBOL program
and executed.
The card deck is shown in Figure 4-1.

$EOJ

$PASSWORD password
$JOB [27,5107]

Figure 4-1

COBOL Print Program Card Deck
4-4

compiled

INTERPRETING YOUR PRINTED OUTPUT
The COBOL program is as follows.
IDENTIFICATION DIVISION.
PROGRAM-ID. COBOLI.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
START.
DISPLAY "THIS IS TO SHOW SAMPLE OUTPUT FROM BATCH.".
DISPLAY "THESE TWO LINES ARE OUTPUT FROM THE PROGRAM.".
STOP RUN.
When the job is run, the program is compiled and a compilation listing
is produced. The listing is shown below. Note that the compiler puts
sequence numbers on the program even though they were not in the
original program.
P ~ 0 G R A ~ COB 0 L 1
LNONlJ.CBL
0'_APR-78 07.01
0001
0002
~OO]

0004
OOO!

0006
0007

0001
0009

IDENTI,tCATJON DIVISION o
COBOLI.
ENVIRONMENT DIVISION.
DATA DIVrSION.
PROCEOUPE DIVIIION.
STAPT.
DISPLAY .THIS IS TO SHOW IAM,Lt OUTPUT 'ROM BATCH,".
DIIPLAY "THESE TWO LINE.' ARE OUTPUT FROM THE P~OGRAM •••
ITOP ~UN.
PPOGPA~.rD.

NO ERROPS DETECTED

After the program is compiled, it is loaded and executed. The program
in this example does not have output to the line printer. Instead its
output is written to a terminal. Because this is a Batch job, the
terminal output 1S written in the log file. The log file is printed
because the end of the job is reached. The log file contains all the
dialogue between your job and the system and system programs, and some
commands that Batch sent to the system for you. An annotated log file
is shown on the following pages. Note that each line in the log file
is preceded by the time of day when the line was written.
Following
the time is a word that describes what kind of information is on each
line. Refer to the DECsystem-lO (TOPS-IO) Batch Reference Manual for
a description and definition of these words.
lU19112 STOAT
1]1:19 112 STCRD
13.39112 STCRO
11.39114 STMSG
11.]9114 STCRO
Il139.14 BTeMO
1),39114 STSTJM
13.39114 STSUp.4
11139,14 STSU~

3-AUG-7.
RK1A7A KL10 aYS'1026
SPRINT V.r.lon 10ZCaOa4)
.-.J08 £27,5107]
.COBoL
'111 oaKILNON]JRCBL Cr._tid - 9 Card. R.ed - 2 Block' written
U:X!CUT!
'~OJ

End of Job Encountlr'd
14 Card. R.ad
Batch I~put P.qUI.t Crl'tld

4-5

INTERPRETING YOUR PRINTED OUTPUT
1114:Z14. BAJ08
13142.44 SA'IL
11142.44 ~A'lL
Il142144 8ASUM
1 Jl42 44 Mt')NTJol
13,4' 44 MONTJol
13142 45 UIEFI
11142 46 U8ER
11142 46 US!:R
1)142 47 MnNTJol
1 )142 47 MONTP
11142 .9 USEP
1314] (\0 MnNT"
11143 00 MONTR
1,.4) 00 MONT"
Il14) 00 MOt-lTP
11.4) 01 lIS!P
III 43 OJ USEP
1,,4) 03 UIER
13143 0) USE'
1)14310) MaNTia
13143,03 "'ONTP
11143103 MONTP
1)14HO) MONTI'

ver.lon 102(206') runnino J80NlI .,qu,ne. 1258 in Itreem 1
Input from DSKCIJ80N]I.CTLL27,5t071
outPut to OSKCIJ~ON]1,LOGt27,!1011
JOb paralt.lt.r.
Tl~"nOln5,oo
Unlqu'IY[S
Jol • • tartIYtl
Outputlt,OG
8~TCON

.LOGIN 27/5101

ID!'!R/&POOLIALL/TIM~1100/LOCATE.26/NAME,"a~OWN,["

JUB 49
R~)A7A KL10 SyS.tO~6 TTy511
[LGNJSP Other job' lame pPNI21
IJ42

02.Au;.7.

W.d

.,COMPIL ICUMP/C08 OIK,LNON]J.C8L/LIST
CUBOL' COBOL 1 [LNON lJ ,CRL)
EXIT
•• EXECUT IJolEL OSK'LNONlJ.REL
LINKI
Lo.dlner
tL~KXCT COBOLt Execution)
THIS IS TO SHO~ ~UTPUT '~UM BATCH.
THES! TWO LINES A~E OUTPUT 'ROM TH! PROGRAM,
EXIT

•
'IP"I'
1Ja4ll01 Bt,A8L "INal

t).43103 MONTR
t)l4310) USEP
lJa43104 US!P
1)143104 USER
11143'04 USER
1)143104 U5[Jol
1)t4l104 MONTP
1314)104 MONTJol
11143,04 USE"
11143104 USEP
13141105 MONTR
1 J14l' 05 MONTR
13143105 MONTJol
1]143105 MONTP

,DELETE DSKILNON3J,CBL,OSKILNON1J,REL

r1le. deleted.

LNON)J.CBL
03 BlOCkS fr.ed
LNON]J,R!:L
0'2 BloCk. fr.ed
,I<JOB/BATCH
(LGTAJL Anothlr job II .tlll lO;;'d-tn Und.r [27,5101l]
Job 49
U.er 8ROWN,E (21,5107J
LO;;ed-off TTY5t1 at 1]14]105 on 2.Au;.11
Runti~.1 01001 0 1, KCSI26, Connect t1~el 0100,20
01.k "e.d •• 916, write'191

4-6

CHAPTER 5
EXAMPLES OF COMMON TASKS WITH BATCH

This chapter shows some sample jobs that are run
from cards.
Section 5.1 illustrates entering
Section 5.2 shows entering jobs from cards. The
in both cases, the difference is in the way that

5.1

from a terminal and
jobs from a terminal.
examples are the same
they are entered.

USING THE TERMINAL TO ENTER JOBS
ALGOL

Example

The first job is a simple ALGOL program that writes output to the
terminal. Since the job is being entered through Batch, the output is
written in the log file instead of on an actual terminal.

SOS MYPROG.ALGGIO

INPUT:

MYPROG.ALG

00100
00200
00300
00400
00500
00600
00700

BEGINGID
REAL X;INTEGER I;GID
X:=l;~

FOR 1:= 1 UNTIL 1000 [10 X := X+I ;QID
PRINT (X);QID
END~

[DSKC:HYPROG.ALGJ
The control file for the program is created as follows.

CD
.SOS MYFILE.CTLQID

INPUT: HYFILE.CTL
00100
00200
00300

.COMPILE MYPROG.ALG/LISTQID
.EXECUTE MYPROG.ALGQ!:D

GO
[DSKC:HYFILE.CTLJ

5-1

EXAMPLES OF COMMON TASKS WITH BATCH
To execute this ALGOL program using the Batch control file, issue
SUBMIT command.

the

CB
.SUBMIT MYFILE~
[INP26:MYFILE=/SEG:4805/TIME:O:05:00J

When Batch starts the job, the statements in the control file call the
ALGOL compiler to compile the program. The TOPS-IO monitor then calls
the loader to load the program for execution.
A listing of the
program will be printed with the log file shown on the following page.
DEC5YSTEH 10 ALGOL.60, VERSION 6A(6J4)
COM~AND

000004
START

01)0005
000005
000015
nOOO21

8T~ING.

or BLOCK t

Oi.AUG.,.

~YPROG,LPTIMYPROr..~YPROG.ALG

00100 BEGIN
00200
O~JOO

00400

00500
000024
El 00600 END
END BLOCK 1 , CONT 0

pEAL X,INTEGER I,
X.·1J
,.OR 11- 1 UNTIl. 1000 DO X
PRIN1' (X)'

5-2

,8 X+l •

EXAMPLES OF COMMON TASKS WITH BATCH
12135155 8AJOB
121351'5 SArlI.
12.35',55 aU"IL
12.35.55 aASUM

BATCON VERSION 1~1(2~07) RUNNING MyrILE SEQUENCE 4805 IN STREAM 5
INPUT rROM DSKCIKyrILE,cTLt27,5107]
OUTPUT TO OSKCIMYFILE,LOGt27,51071
JOB pARAMETERS
TI Mt,OOl05100
UNIQUE,y!S
REITART.NO
OUTPUT'LOG

12 35,55 MONTR
12 3515' MONTR
12 35.56 USEP
12 36.00 USER
12 ](11)0 USER
12 36101 MONTR
12 36.01 MOI'.ITP
t2 36,03 USER
12 36104 MONTR
12 36 04 MONTP
12 36 04 MQNTR
12 36 04 MONTR
12 36 05 USER
12 36 06 USER
12 36 06 USER
12 36 06 USEP
12.36 06 USER
12136 06 MONTR
12.36 06 MONTR
12.36 07 USEP
12.36 01 USER
12.36 08 MQNTR
12.36 08 MoNTP
12,36 08 MONTP
12136 08 MONTP

tLGTAJL ANOTHER JOB 18 STILL LOGGEO.IN UNDt~ [27,5107)J
JOB 26 USEP BPO~N" [27,5107)
LOGGEO-Orr TTY513 AT 121]6107 ON I_Aua-78
RUNTl~EI 0.00101, J(CII12, CONN~CT TIM!, 0100.11
OlS~ READI,646, WRIT~SI24

12136,09 LPOAT
12136,09 LPDAT
12'36113 LpMSC;
12.36.11 LpMSG

LPTSPL VERSION to)(2421)
pKJA7A KL10 8Y8'1026
JOB MyrtLE SEQUENCE .4805 ON LPT261 AT l-AUG-7S 12'36109
[LPTSTr STARTING rILE OSKC,QP US26.LPTCl,lJl
tLPTrpr FINISHED PRINTING rILE DSJ(CIQPOS26,LPTC),llJ

,LOGtN 27/5107 IDEfEP/SPOOL,ALL/TIME,300/LOCATE,26/NAMEI"BMOWN,E"
JOB 26
RK3A1A KL10 Sy$'1026 TTy513
[LGNJ8P OTHER Joes SAME PPNI46J
t236
ot-AUG-'9
TU!
,.COMPILE MYPROG,ALG/LIST
ALGOL. MYPROC;

EXIT
,.r.Xe:CUTE MVPROG.ALG
LINK,
LOADING
[LI'.IKXCT MYPPOG EXECUTION]
1,0010000' 1
END or EXECUTION,
.J(JOe/BATCH

5-3

EXAMPLES OF COMMON TASKS WITH BATCH
BASIC

Example

The second example is a BASIC program submitted to Batch.
You can
make up the program file using BASIC and save it on disk. Then make
up a control file that simulates the dialogue with the BASIC system.
The program is shown below .
• R BASIC~
READY
NEW~

NEW PROGRAM NAME--MYBAS.BAS~
READY
00100
00200
00300
00400
00500
00600
00700
00800
00900
01000
01100

INPUT D~
IF D :::: 2 THEN 1100~
PFnNT -X VALUE-, -SINE-, -RESOLUTION"~
FOR X::::O TO 3 STEP D~
IF SIN(X)<:.-:M THEN 800~
LET XO=X~
LET M::::SIN(X)~
NEXT X~
PRINT XO,M,D~
GO TO 100~
END~

SAVE~

READY
MONITOR~

The program requests data from the your terminal when it is running.
You include the data in the control file.
For this program, the final
data item must be 2 to conclude the program.
The control file
follows.
GQ

.sos BASIC.CTL~

Input: BASIC.CTL
00100
.R BASIC~
00200
*OLD [lSK:MYBAS.BAS~
00300
*RUN~
00400
*.1~
00500
*.01~
00600
*.001~
00700
*2~
00800
*MONITOR~
00900
$

[BASIC.CTL.1]

5-4

EXAMPLES OF COMMON TASKS WITH BATCH
The output from the program will be printed as part of the control
file
listing.
The command to submit the job to Batch is executed as
follows.
~

.SUBMIT'BASIC.CTL~
(INP26:BASIC=/Sea:4823/Time:O:OS:OOJ

12.48.40 SAJOB
12148140 BArIL
12148140 BArIL
12.48140 BASUM
12.49.40 MONTR
12148140 MQNTP
12.48141 UStR
12 48,4.1 USEP
12 48,43 USER
12 48.44 MONTR
12 481 4 4 "iONTR
12 48144 USER
12 4814\5 USER
12 48 45 USER
12 48 45 USER
12 48 45 USER
12 48 45 USER
12 48 45 USEP
12 48 45 USER
12 48 45 USER
12 48 45 UsER
12 48 45 USER
12 48 45 USER
12 48 45 USgR
12 48 45 USEP
12 18 45 USER
12 48 45 USEP
12,48 45 UsER
12.48 45 USER
12.48 45 USER
12148 45 USER
12148 45 USER
12148 45 USER
12149 46 US!R
12148 46 USER
12 48 46 tlSER
12 48 46 USER
12 48 46 USER
12 48 46 USEP
12 48 46 IJSER
'. '2 48 46 ~nNTR
12 48 46 MONTR
12 48 46 USEP
12 48 46 USE~
12 49 41 MONTR
12 48 47 MO~TR
12 48 47 MO~ITP
12 48 47 MONTP

12.48,49 LPDAT
12149,49 LpDAT

SATCON VERSION 103(2201) RUNNING BASIC SEQUENCE 482] IN ITR!AM
INPUT FROM D8KCIBASIC,CT~[~7,5107l
OUTPUT TO nS~CI8AS1C.LOG[27,S101J
JOB PARAMETERS
TtMEInOl05100
UNIQUElyES
PE8TARTINO
OUTPUT.LOG
.~OGIN 27/5107 IOErERISPOOLIALL/TIME,lOO/LOCATt.26/NAME.-BROWN,E"
JOB 30
R~lA7A IeLIO syStl026 TTY5n4
[LGNJSP OTHER JOBS SAME pPNI46J
1248
Ol.AUG.1e
TUE

IIR BASIC

PEAOy. rUR HELP TYPE HELp,
OLD
OLD rI~! NAME •• DSK,MrSAS.BAS
RI!.:AOy
RUN

MYBAe

12,48

1,1

X VALUE

SINE
O,999~74

1,6

1,Ot
x VA~UE
1.!'7

7,Oot
X VALUE
1.571
72

TIME.

RESOLUTION
0,1

SINE
t•

RESOLUTION

SINE

RESOLUTION

0,01
0.001

1•

0.26 SEes.

READy
MONITOR
,KJOB/BATCH

[LGTAJL ANOTHER JnB IS STILL LOGGEO-IN UNDER t27,!5107JJ
Jue 30 USEP BROW~,E (27,5107]
LUGGEo.orr TTY504 AT 12'48'41 UN t.AUG.78
RUNTI"i[. 0100100, KCSI9, CUN~ECT TIME. 0100106
Dts~ PEAOS.Q4, WRIT'S.6
LPTSPL VERSION 10)(2421)
RKlA7A KL10 5Y8'1026
~AStC SEQUENCE .4823 ON LPT261 AT t.AUG.7A 12148.49

JO~

5-5

EXAMPLES OF COMMON TASKS WITH BATCH
FORTRAN

Example

The third example is a FORTRAN program that prints output on the line
printer.
You want to tell Batch in the control file to delete your
relocatable binary file if an error occurs when your program is
executed.
If an error does not occur, you want Batch to save your
relocatable binary file as it normally would. The program is shown
below.

.SOS MYPROG. FOR~
Input: MYPROG.FOR
00100
C
THIS PROGRAM CALCULATES PRIME NUMBERS.GiQ
[to 10 I := 11 , 50, 2 @)
00200
J=lG!2)
00300
4
J=J+2@)
00400
A==J~
00500
A=I/A@)
00600
L::::I/JG0
00700
B:::A'-L~
00800
IF (B) 5,10,5~
00900
IF (J.LT.SQRT(FLOAT(I») GO TO 4~
5
01000
PRINT 105,I@)
01100
CONTINUE~
10
01200
FORMAT (14, , IS PRIME.')~
105
01300
END~
01400
01500
$

CDSKC:MYPROG.FORJ

You create the control file to compile and execute this program,
deleting the relocatable binary file if there is an execution error as
follows.
~

.SOS'MYFOR.CTLG8
Input: MYFOR.CTL
00100
.COMF'ILE Mypr~OG.FORG8
00200
.EXECUTE MYPROG.REL~
00300
.IF(ERROR) .DELETE MYPROG.FORG:Q
00400
END: : ! END OF JOB GB
00500
$

OD
CDSKC:MYFOR.CTLJ

You submit this job for execution as follows.
G!:)

.SUBMIT'MYFOR.CTL~

CINP26:MYFOR=/Sea:4834/Time:0:OS:00J

5-6

EXAMPLES OF COMMON TASKS WITH BATCH
The program output is as follows.
11 1. PRIME.
13 15 PRIM!.
\1 IS PRIME,
19 15 PRIM!.
23 IS PRIME,
29 15 PRIME.
11 IS PRIME.
31 IS PRIME.
41 IS PRIME.
41 IS PfnfoAt.
4' IS PRIM!.

The log file produced by the job is as follows.

1310114& RAJOB
1310\148 aAFIL
13101148 a"rIL
1.).01.48 BASUM
11101148 MONTR
13101148 MONTR
13' (\.1' 4. e USER
1310tl51 USER
11101.51 USe::R
11101.52 MONTR
\1 01 52 MQNTP
13 01 53 USEP
11 (II 55 USER
13 01 55 MONTR
13 01 55 MONTR
13 01 56 USEP
13 01 57 USER
13 ot 1.59 USER
1.) 01 59 USER
13 0 t 59 USER
13 ot 59 MONTR
1) 01 59 MONTR
13 01 59 t.lONTR
13 01 59 FALSrr.
13 Ot 59 BLASL
1)101159 MaNTR
IllOI.59 USER
1310tl59 USER
'3102101 MONTR
13102.01 MONTP
11102.01 MONTR
13102101 MONTR
13112,35 LPOAT
13112135
\H12138

LPOAT
LPMSG

13112144 LPMSG

BATCON VERSION 101(2~01) RUNNING MyrOR SEQUENCE 4834 IN
INPUT fROM DSKC'MyrOR.CT~t27,51071
OUTPUT TO DSKCIMyrOR.LOG[27,5107]
JOB pARAMETERS
TIMEIOO.05100
UNIQUEIYES
RESTART,NO
OUTPUTILOG

8T~tAM

.LOGtN 27/5107 IDE'ERISPOO~'ALL/TIMEIJOO/~OCAT!'~6/NAMEI"8~OWN,!"
JOe 30
RK1A1A KL10 SySfl026 TTY504
tLGNJSP OTH~R JOBS SAME pPNI46J
110t
01-~UG.7e
rUE
,.COMPILE MYPROG,rOR
FOPTRAN, MYPROG
MAI~.

•• EXECUTE MYPROG.REL
LINt( I
1I0ADING
[LNt(XCT MYPROG EXECUTION)
END or EXECUTION
CPU TIM!I 0.04 ELAPSED TIMEI 0,65

EXIT

•• lr (ERROR) .D~LETE MYPRoG.rOR
ENO ••

,END or JOB
.I<JOS/BATCH

tLGTAJL ANOTHER Joa 15 STILL LOGGED-IN UND~R [27,5107Jl
JOB)O USER BROWN,E (27,5107]
LOGGtD_Orr TTYS04 AT 13.02.01 ON
t-AUG-7S
~UNTIM!. 0.00.60, KCS'lt, eONNECT TIME, O'OO'l~
OISK ~EAOSll02u WRtT!S'19

LPTSPL V!RStON 103(2421)
RK1A7A KLI0 SY5'1026
JOB MvrOR SEQUENC! .4834 ON LPT261 AT i-AUG-78 13113135
[LPTsTr STARTING rILE OSKC,QP1826.LPTt],]ll
(LPTrpr rINISHED PRINTING FIL! DSKCIQP1S36.LPTt],]ll
COBOL

Example

EXAMPLES OF COMMON TASKS WITH BATCH
with the physical drive assigned.
The MOUNT command also informs the
operator of the name or ID number that identifies the particular tape
you want mounted.
(Your tape should be given to the operator or
stored at the central site before you submit your job.)
You create
the program as follows.

.SOS MYPROG.CBL~
Input: MYPROG.CBL
00100
IDENTIFICATION DIVISION.~
00200
ENVIRONMENT DIVISION.~
00300
INPUT-OUTPUT SECTION.~
00400
FILE-CONTROL.~
00500
SELECT OUTFIL. ASSIGN TPDRIV.~
00600
DATA DIVISION.~
00700
FILE SECTION.~
00800
FD OUTFIL LABEL RECORDS ARE STANDARD~
00900
VALUE OF IDENTIFICATION IS ·INFIL DAT·G:Q
01000
DATA RECORD IS OUTRECQIQ
01100
BLOCK CONTAINS 20 RECORDS.~
01200
01 OUTREC PIC X(80).~
01300
WORKING-STORAGE SECTION.~
01400
77 A PIC 9999 USAGE IS COMP.~
01500
PROCEDURE DIVISION.~
01600
START .~
01700
OPEN OUTPUT OUTFIL.GIG
01800
MOVE ZEROS TO OUTREC.~
01900
MOVE 1000 TO A.~
02000
LOOP.~
02100
WRITE OUTREC.~
02200
SUBTRACT 1 FROM A.~
02300
IF A IS GREATER THAN ZERO GO TO LOOP.~
02400
CLOSE OUTFIL.~
02500
STOP RUN.GIQ
02600
$

CDSKC:MYPROGrCBLJ
You create the control
(PROGl.CBL) as follows.

file

(COBJOB)

used

run

G:)

.SOS'COBJOB.CTLGIQ
Input: COBJOB.CTL
00100
.MOUNT MTA:MAG1/REELID:SCRTCH/WENABLE~
00200
.COMPILE MYPROG.CBL/LIST~
00300
.EXECUTE MYPROG.CBLGIQ
00400
• DISMOUNT MAG1:GIQ
00500
$

CDSKC:COBJOB.CTLJ

5-8

the

program

EXAMPLES OF COMMON TASKS WITH BATCH
You submit the job for execution as follows.

.SUBMIT~COBJOB.CTL~
[INP26:COBJOB=/Sea:l072/Time:O:OS:OOJ
The log file produced by COBJOB is shown below.
12134125 BAIloe
12.34125 BArIL
12134125 BAFIL
12134115 BASUM

SATCON yerllon 103(2207) runn1ng COSIlOB lequence
Input from DSKBICOSJOB.CTLt27,5031]
output to DSK8IC08J08.~OG[2,,!031]

Job parameter a

un1que,y!s

T1me~OOI05100

12 34 25 MQNTR
12 34 25 MONTP
12 34 2~ USEP
12 34 26 USER
12 34 26 USER
12 34 31 USER
12 34 3' US!R
12 34 32 MClNTR
12 34 32 MO~TR
12 34 34 lISEE'
12 34 34 USER
12 36 01 USER
12 36 01 MnNTR
12 36 01 MONTP
12 36 0\ USEP
12 36 08 MONTR
12 36 08 MQNTP
12 16 08 MONTP
12 J6 08 MQNTP
12 36 08 USE~
12 36 09 US~P
t 2 16 t 1 MONTP
12 36 1\ MONTP
12 36 11 MQfIITP
12 36 it MONTP
12 36 13 USEP
12 36 13 IJSEP
i 2 36 13 USl:P
12 36 13 USEP
12 37 58 US~F
12 37 '58 MoNTP
12 37 58 MQNTP
12 37 58 USEP
12 37 58 USER
12 31 59 USER
12 31 59 USER
12 31 59 USEP
12 37 59 USEP
12137159 LPDAT
12.371'59 LPOAT

,LOGIN 27/5031

pe.tartlNO

107~

1" .tre.m 1

OutputlLOG

IOErERISPOO~'ALL/TIMEIlOO/NAME'"LAMAR.8"

JOB 13 KIlO SYS 514C 60]A TTY101

CLGNJSP Other job' •• me PPNI14J
tLGNROU Recomputing dl.k UI.9.l
[LGNQTA os,e INI10000 OUTI5000 USED.16601
la14
02-AUg-'9
wed

•• ~OUNT MTAIMAGt/PEELIOISCRTCH/WENASLE
ReqUe.t queued
Wa1t1nQ ••• 2 -Cf. to EX1t
MAGI mounted, MTAOOl u.ed
•• COMPILE MYPROG,CBL/LIST
COBOtl MAIN [MYPROG.CBLl
EXIT
.~rXECUTE MYPROG.C8~

LINKI

LoadlnQ

[LN~XCT

~YP~OG

Execution]

EXIT

•• DISMOUNT MAGill
[MTAOOlISCRTCH WRITEtC/H/S) • 75110/0/0]

R'quelt queu.d

waltlnQ ••• 2 ·e'l to
MTAOot 011mounttd

E~lt

.KJOB/BATCH

tLGTAJL Another jOb l' .tlll logoed-ln Under [27,5031lJ
JOb t ] U.er L~MAR,B 127,5031]
LO~Qed-off 11"10) et 12137159 on 3-AuO. 1 8
Runtl~'1 nlo~.o4, KC5176, tonnect time. 0,03131
011k pead11292, wrlte'110e
LPTSpL yer'lon 103(3421)
KIlO Sys 514C bOlA
JOb COBJOB .eqUlnee -1072 on LPTOOO It 2-AUQ.,e 1"137159

5-9

EXAMPLES OF COMMON TASKS WITH BATCH
5.2

USING CARDS TO ENTER JOBS
ALGOL

Example

The first job is a simple ALGOL program that writes its output into
the log file because it has statements that would cause it normally to
write to the terminal.
The program is as follows.
BEGIN
REAL XiINTEGER Ii
X : =1 i
FOR I :=1 UNTIL 1000 DO X:=X+li
PRINT (X) i
END
The cards to enter this program are shown in Figure 5-1.

$EOJ

$JOB [27,5107]

Figure 5-1

ALGOL Job Entry Card Deck

5-10

EXAMPLES OF COMMON TASKS WITH BATCH
The output, including the log file, is shown below.
131)9,16 STOAT
11139116 STCRO
11139116 STCPO
11139111 STMSG
131:19,17 STCPO
\31]9117 STC~O
11139117 STSUM
131:19117 STSUM
11139,17 STSU~

~K3117A KL10 SYSI1026
SP~INT Ver'lon 102(2024)
a-AUG-7S
,JOB [27,5107)
,ALGOL/NOLIST
r111 OSK'LNON3L.ALG Crlattd - ~ C.rd, RI.d • 1 Bloe~. written
n:XECUTII;
'[OJ
End of Job [neOunttrl d
11 Card. ,.,.d
aateh Input PlqUllt Crlatld

131431 06 IUJOB
13,43,06 8AfIL
\3143,06 SArIL
11143106 BASUM

SATCON ver.ion 102(2 0 67' runnlnq JOBON1K 'lqUlnet 1259 In
Input from OSKCIJ~ONlK,CTLt27,51071
outDut to OSKC'JBON)K.L~G[a7,51071
JOb per.III'tlr'
Tlm.,OOI05,OO
UniqU.,y!S
pe.tart,YES
output,LOG

11,4] 06 MONTN
11.4] 21 ~ONTP
13143 22 usr"
13143 23 USEP
1J14] 23 USER
13143 24 MONT ..
13,43 24 MONT~
13143 27 USEP
1114) 27 MO~T"

11143 27
13143 27
11143 27
11143 28
13143 31

,LOGIN 27/5107 l~trEP/SPOOLIALw/TrM!IJOO/LOCATE'26/NAME'·8"OWN,E"
JUB 49
~KJA7A KL1~ SYS'10~6 TTY!ll
[LGNJSP Othlr lobi .em, PPN'2tJ
114J
n~.Auo-78
Wid
.,COMPIt ICOMP/ALG DS~.LNONlL,ALG
ALGOL' LNON1L

MONTP
MONTP

EXIT

~ONTP

,.EXECUT IREL OSK.LNON1L.R~L
LINKI
LoadlnO
[LNKXCT LNON1L EXleutlonl
t,ootOOOOI. 1

Us!:p

usr ..

'H4) 32 US!:~
t 1143 32 USE ..

11143 32 Us[~
11143 32 ,",ONTP
13,43 :32 MONT ..
13 43.13 BLASI.
1) 43.12 MONTR
1) 43.32 USER
13 43111 USER
1] 43,33 US!.""
tl 43.33 USEP
13 43.13 US!P
11 43.31 MONTP
13 43.13 MONTP
t 3 41131 USER
tl 4].13 USEP
13 43,55 MO~TP
13 43155 MONTP
1] 43,55 MONTA
1) 4311S5 MONTP

.tr.a~

•
'tRP,.

,rIN,.
.OEL[T£ DIK'LNON1L,ALG,DaKILNON1L,pEL
r11e. dll.t.d,
LNON]L.ALG
01 Sloek. fr.ed
LNON]L,REL
01 Bloek. fr.ld
.KJOB/BATCH

[LGTAJL Anothlr jOb l' .tlll lo09'd-ln Undlr C27,5107]]
JOb.9 U.lr BROwN,! [21,5101)
LOQOed-oft TTylll at 13.43.55 On 2.A~O.78
Nuntl~"
OIOOIOl~ Kca'11, Conn.et tim •• O,OO.J2
Dllk R.ad.1645, writ",19

BASIC

Example

The next example shows how to enter a BASIC program. You must precede
the program commands with a $CREATE card so that the program will be
copied into a file on disk. No $DATA card can be used because BASIC
does not use the EXECUTE command and because the data is entered by
means of the control file:
the program req~ests data when it is
running;
it finds the data in the control fil~. For this program the
final data item in the control file must be 2 so that the program can
be concluded. The program is shown on the following page.

5-11

EXAMPLES OF COMMON TASKS WITH BATCH
5
10
20
30

40
50

60
70
80
90
100

INPUT 0
IF 0=2 THEN 100
PRINT "X VALUE", "SINE", "RESOLUTION"
FOR X=O TO 3 STEP 0
IF SIN(X)=M THEN 80
LET XO=X
LET M=SIN(X)
NEXT X
PRINT XO,M,O
GO TO 5
END

The cards to enter the program and run it are shown in Figure 5-2.

*2
*.001

*RUN
*DSK:MYBAS.BAS
*OLD

$CREATE MYBAS.BAS

Figure 5-2

BASIC Job Entry and Run Card Deck
5-12

EXAMPLES OF COMMON TASKS WITH BATCH
The output from the program will be printed in the log file because it
would normally be printed on the terminal. The log file is shown
below.
13.39119 STOAT
\).19119 STCRD
13139119 STCRO
lJ139.21 STMSG
13.39.21 STCRO
11139.21 STCRD
11119123 STCRD
11.:19,21 STSUt.4

11.19123 STaUM
11139123

STSU~

13a43,56 BAJOB
11143156 IUrlL
13143,56 8ArIL
IH43156 BASUM
13 4l,56 MONTR
13 41156 MONTR
13 43,5'7 USER
13 441t0 USER
t3 44110 US!P
11 44.11 MONTR
11 44.tt MONTI'
tl 44.tt USEI'
tl 44.tl UStR
13 44atl USER
13 44111 USER
13 44.13 UStR
13144.12 USER
11144.12 USE ..
13a44.t2 USER
11144.12 UStR
1]144112 USER
11,44.12 USER
11144,12 USER
13144112 USEP
ll144,12 USEP
11,44.12 USER
13844,12 USER
tl 44a12 USER
13 44.12 UeEP
13 44112 USER
11 44.12 UStR
t1 44.12 USEI'
11 44.12 US!:R
11 44112 US!:P
13 44112 USER
II 44t12 USEP
13 44112 USER
13 44112 US!:R
13 44,12 USER
11 44112 USER
13 44112 MONTR
1] 44112 MQNTR

3-AUG-'7'
RKll'7A KL10 SYI.l026
SPRINT Verlton lU2(2024)
.JOB [2'7,510'7)
,CREATE MY~AS.8AS
F11. nS~IMY~A5.&A8 Cre.tt~ - ~1 C.rda R•• ~ - 2 el0c~a Wr1tttn

.too

.TOP8tO
.1.0.7

End of Job EnCo~nttrtd
2b C.rd. Pt.d
satCh Input Rtq~elt Crt.ttd

BATCON Vlralon 102(2067) runnlnq J80NlM IlqUlne~ 1:260 l~ Itrt.m 1
Input from OSKC.4BON)M.CTLt2'7,510'7)
Output to DS~CIJeO~]M.LnG[2'7,510'71
JOb par.mlttr.
Tl me.OO,05,OO
Unique.y!.
RI.t'rt.VESOutPut,LOG

• LOGIN 27/5107 I'DEFERISPOOL' ALL/TIME .lOO/LOCATE I ~6/NAM.;' "BfCOWN, E"
JOB 49
RKlAfA ~Ll0 SY"10~b tTySt'
[LGNJSP Othtr jOlbl •• me pPN. 21 J
1144
02_AuO-'71
w.d
.,R aASIC

READy, rOR HELP TYPE HELP,
*01,,0
OLD rILE NAME--*DI~.MYBAI.eAS

READy
*tilU~

MYBAS

11144

' •• t

SINE

X VALUE
0

"·,01

X VALUE

RESOLuTION
0.1

SINE

Rt80LU'J'ION

'*,onl

X VALUE

SINE

'·2

TI~EI

0.01

RESOLuTION
0.001

0.09 stes l

R~~ADY

*~ONITOR

•

,tRR ••

ATN!er End of the contrOl f11t whill "'rchino fOr 'fIN
ll14411:2 MQNTR
13144112 tlS!P
13.441\2 USER
11144,11 MONTR
11144.13

~ONTP

'.3144.13 MONTFt

11144,13

MO~TA

.I<JOB/BATCH
[LGTAJL Another job l ' Itill lO;Qtd-ln under [21,5107Jl
BROWN,~ t2'7,!107]
LO;O.d-off TTy511 at 13144'13 on a-Au;-"
~untlm., oloo.on, KellS, Conn.et tlml' 0100,16
Milk Rt.d,,8e, Wrlt'~16
JOb 4 9 u.er

5-13

EXAMPLES OF COMMON TASKS WITH BATCH
FORTRAN

Example

The third example shows a FORTRAN program that prints output on the
line printer. In the control file, you want to tell Batch to prevent
execution if the program compiles incorrectly.
C
4

5
10
105

THIS PROGRAM CALCULATES PRIME NUMBERS FROM 11 TO 50.
DO 10 1=11,50,2
J=l
J=J+2
A=J
A=I/A
L=I/J
B=A-L
IF (B) 5,10,5
IF (J.LT.SQRT(FLOAT(I))) GO TO 4
PRINT 105,1
CONTINUE
FORMAT (14, 'IS PRIME.')
END

The cards used to enter this program are shown in Figure 5-3.

$EOJ
END::! END OF JOB

$FORTRAN/LIST
$PASSWORD password

Figure 5-3

FORTRAN Card Deck That Prevents Execution
on Error

5-14

EXAMPLES OF COMMON TASKS WITH BATCH

Batch puts the following commands into the control file as a result of
the cards you entered .
. COMPIL /COMP/FIO DSK:LNON3F.FOR/LIST
.IF (ERROR) .GOTO END
.EXECUT /REL DSK:LNON3F.REL
END:: !END OF JOB
.DELETE DSK:LNON3F.FOR,DSK:LNON3F.REL

Program output is as follows.
MAIN,

LNONlf.'OR

00001
/)0002
0000')
00004
000('5
00006
00007
00008
(\00('19
00010
1)0(111
00012
00011
00014

'O~TRAN

V,!A(631) IKI

1 Jl41

THIS P~OG~AM CALCULATES PlUME NUMBe:~S.
00 10 1-11,50,2

13-'
J-J+a
AaJ

AaI/A
L'I/J
e,A-L
Ir(8)5,IO,5
5

Ir(J,LT.IQ~T('LOAT(t»)
P~tNT

10
105

SUBP~OG~AMI

GOTO 4

10!,1

CONTtNU!
P'O~"'AT(l4,

, 15 PftIME,')

END

CALLED

SQRT,
'LOAT.
SCALARS ANO ARRAYS

••• NO e:XPLICIT Oe:rINITION - "'" NOT ~e:'!RENC!D

TEt04PORARIES

.Qooon 1)
MAIN.

[NO !RROMI DETECTED )

11 IS PRIME.
11 IS P~IM!.
l ' II PRIME.

19 II PlUM!:.
21 IS PPI"'!:,
29 IS PRIME,
31 IS PPIt.4E,
37 IS PRIME.
41 IS PRIME.
41 IS PPI~!,
47 IS PRIM!.

5-15

.SOOOO 4

·L

PAGE 1

EXAMPLES OF COMMON TASKS WITH BATCH
The log file produced by the job is shown below.
11119.59 STOAT
13138.58 STepn

2·AUG-18
RK3A7A
,JOB [2",SIO'}

1)1)8.58 STCPD
\3139,01 STMSG
1),19101 ST~RO
11139,01 STCRO
13,3«),01 STCPD
13139,01 STC'RD
1l139.01 STSUM
13.]9,01 STSUM
11.39,01 STBUM

"'ORTRAN/LIST
Ylle OSKrLNONlr,rop cre.ted - 14 Card. Read. 2 BlOCk. Written
'~~PO~

~LlO

SYS.l~l6

SPRINT Vtr'lon

~02(2024)

,COTo [~D

U:XF.C UT !

.TOPS10
'~OJ

End of Job EnCount.r.d

:n Card. Peed

BatCh Input RtQue.t Creat.d

11141,51 MONTP
1),41.51 MONTP
11141,51 MONTR
1314\ ,51 MONTR

JOh 49 u.er

11,41,;Z7 liAJ08

BATeoN ver.lon 102(3067) runn1no JeONl! .equene. 1256 1n .tream 1
In~ut from OSKC.JAONlE.CTLtl7,510.,)
output to DS~CIJBONl~.LOGt27,5107)
JOb ~aram.t'r.

13141127 liArIL
131411'27 BArIL
13,4t." SA SUM

B~OWN,E

Time.OOI05.00

13141 27 MONTA
11.41 27 MONTR
1314\ 29 USER
11141 J1 USEP
11141 31 USER
13.41 J2 MONTR
1) 41 32 MONTFl
1] 41 34 ustP
1] 41 4] USER
13 41 44 MONTR
11 41 44 MONTR
13 41 44 'AI"S!:
\3 4\ 44 MO~TR
11 41 45 USER
1] 41 40:' U5!:R
13 41 49 USER
13 41 48 USER
13 41 48 USER
13 41 48 MQNTFt
13 41 48 MONTR
13 41 48 ~ONTP
13 41 48 8LABL
13141148

~LABL

13.41148 MONTR

13.41.49 USEP
13141149 usrp
13.41149 USEP
13,4\150 UsER
lJl41150

lJS~P

t3.41150 MONTP
13.41.50 ~(1NTR
13141150 USEFI
13.41.50 USEP

[21,510"J

LO;;.d-ott TTY'11 at 13.41.51 on 3.Au;-78
puntl~'1 OIOOIOt, KC5'25, Conn.et tlmel 0100.23
01.k R.ad •• 127~, wr1te.,31

unlquelY!S

Pt.tart,YES

Output.LOG

,LOGIN 37/5101 IO!rtR/8POOL'ALL/TIMEI100/LOCAT[126/NAMElwB~OWN,tw
JOB 49
RK1A.,A KL10 SyS'1026 TTY511
[LGNJ8P Other job' .am. PPNI21J
1141

02.AuO-78

•• COMPIt ICOMP/'tO

P'ORT~lNI
~AIN.

wed

OSK.LNONlr.rO~/LlST

L~ON]r

,GOTO tND
IPEL DSK.LNONlr,R[L
J,,1 NK 1
,",oadln;
[L~KXCT LNON3' Exeeution]
,Ir(E~RO~)
.~XECUT

END
EXECUTION
CPU TIMEI 0,04 ELAPSED TIMEI 0,17
EXtT
-

,
END'I

l~NO OF JOB
'tRRII
,P'INi'
,OEL!TE DS~.LNON)'.FOP,DSKILNONlr,REL

Yl1e. t1elttedl

LNON]Y,rOp
02 Blockl treed
LNON)r.FlEL
1)2 BloCk. tre.d
,KJOS/BATCH

tLGTAJL Another jOb 11 Ittll loQOed-ln Under C27,51071J

5-16

EXAMPLES OF COMMON TASKS WITH BATCH
COBOL

Example

The fourth example is a COBOL program that writes record output on a
magnetic tape.
To have a tape drive assigned and your magnetic tape
mounted on it, you must make a request to the operator. Since you do
not know which drive will be assigned to your job, you must assign it
in your job with a logical device name. The TMOUNT command assigns
the drive to your job and associates the logical name that you specify
with the physical drive assigned. The TMOUNT command also informs th~
operator of the name or ID number that identifies the particular tape
you want mounted.
(Your tape should be given to the operator or
stored at the central site before you submit your job.) The program
is as follows.

IDENTIFICATION 'DIVISION.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT OUTFIL ASSIGN TPDRIV.
DATA DIVISION.
FILE SECTION.
FD OUTFIL LABEL RECORDS ARE STANDARD
VALUE OF IDENTIFICATION IS "INFIL DAT"
DATA RECORD IS OUTREC
BLOCK CONTAINS 20 RECORDS.
01 OUTREC PIC X(80).
WORKING-STORAGE SECTION.
77 A PIC 9999 USAGE IS COMPo
PROCEDURE DIVISION.
START.
OPEN OUTPUT OUTFIL.
MOVE ZEROS TO OUTREC.
MOVE 1000 TO A.
LOOP.
WRITE OUTREC.
SUBTRACT 1 FROM A.
IF A IS GREATER'THAN ZERO GO TO LOOP.
CLOSE OUTFIL.
STOP RUN.
The cards to enter this job are shown in Figure 5-4.

5-17

EXAMPLES OF COMMON TASKS WITH BATCH

$EOJ

.DISMOUNT MAG1

,MOUNT MTB:MAG1/REELID:SCRTCH/WENABLE

.PLEASE MOUNT A SCRATCH TAPE A

[

$PASSWQR D password

Figure 5-4

COBOL Program Card Deck Using Data From Magnetic Tape

Batch puts the following commands into the control file for you .
n

. PLEASE MOUNT A SCRATCH TAPE
.MOUNT MTB:MAG1/REELID:SCRTCH/WENABLE
.COMPIL /COMP/COB DSK:LNON3H.CBL/LIST
.EXECUT /REL DSK:LNON3H.REL
.DISMOUNT MAGI:
.DELETE DSK:LNON3H.CBL,DSK:LNON3H.REL
[

The log file from your job is shown on the following page.

5-18

EXAMPLES OF COMMON TASKS WITH BATCH
1]139.04
\31J9104
131:19.04
1)139.04
13139110
11139.20
13139,10
t3l39110
11119110
13.39110
11139111

STOAT
STCRO
STC~D

STCPD
ST'-4SG
STCPO
8TCRO
STCFtO
STSUM
STSU'-4
STSU'-4

t3141.52 HAJOB
131411'52 BAfIl.
13141152 BArIL
tJ14t152 a~SUM

13 4tl52
13 4' 52
\ 3 41 53
13 42 00

MONTR
MONTP
USEP
USER
USER
M(JNTP
"'ONTP
HATCH

1 j 42 00
13 42 Ot
1) 41 01
II 42 0\
, 3 42 0' "1nr~TP
1 ) 42 02 USEP
13 12 03 USEP
1)

42 24 USER

MONTP
MONTP
1) 42 15 USltP
13 42 35 MQNTR
1 J 42 15 MONTFt
1 J 47 24
1 ) 42 24

13 42
1 ) 42
t) 42
11 42
1 ) 42
\l 42
, 3 42
13 42
\ 3 41
13 42

J! ~('INTP
35 Mt'lNTP
36 U5ltP

38 'JSEP
40 USEP
41') USEP
40 USER
40 MONTJ:!
40 ustp
41

usn~

13 42 41 USER
1 J 42 41 USEP
t ) 42 41 MONTR
\ ) 41 41 MONT~

13 42
1 J 42
! 3 41
1) 42
13 42

SLASL

41 "40NTR
4\

tlSER

42 UsEP

41 USER
1 J 42 42 USEP

13 42
1.1 42
13 42
13 42
13 42
1 ) 12
13 42
13 42
11 42

47 usEP
42 MONTP

42 MONTP
42 USk:P
42 USER

~ONTP

4] MONTP

543__

~10NTP

MONTR

~K3A1A

2-AUG_19

KL10 SYS.\026

SP~I~T

Ver.ton 102(2U24)

'JOB [27,51n7)

,TOPstO
,COBOL
r11e PSk'LNON1H.C8L cr •• ted
U:XI!:CUTE
.TOpstO

25 Carda Reid. 4 Bloe~ Written

,fo:OJ

End of Job EnCOUntered
3ft Card, "ead!
BatCh Input ~.qu.'t creatld
BATCON ver.len 102(2067) runn1no JBON1G ,.qu.ne. 1257 in
In~Ut trom OS~CIJ80NJG,CTLt27,5l07)
Output to OSKC'JeON1G.~"Gt27,5l07J

.t...

JOb Darameter'.

Tlme.nOI05.oa

UnlQuelY~S

9"~.rtIY!5

OutPutlLOG

.LOGIN 27/510' IO!'E~/SPOOLIAL~/TIMt'lOO/LOCAT!126/NAMtl"8'OWN,t"
JOB 49
~K3A'A KL10 Syatl026 TTySt!
CLGNJSP Other jo~ •• am. PPNlll~
1341
02._u;_1e
W.d
••PLEASE MOtrN'I' A SCRATCH TAPE- [
.~OUNT

MT8.MAG1/R!!LIDISCRTC~/WENA8L~

"equelt queul!d
walt1nQ ••• 2 ·C', to ~Xl~
MAGl mount'd,

MT~264

U"d

•• COMPlt ICOMP/COB D8KILNONlH,CBL/L1Sl
CU~OLI

MAI~

tL~ONlH.C8~l

EXIT
•• EXECUT IREL DSKILNON3H.REL
LoadlnQ
[LN~XCT LNONlH tx.c~tlonl

LINK.

EXIT
.,DISMOllNT MAGll
tMT8,-64ISCRTC~

W~ITE(C/H/!)

• 751JO/O/OJ

Rtqu •• t queued

wa1ttnQ,.,2 ·C', to ~~lt

~TB264

pi,mount.d

lEND OF JOB
'I£PR"

'''INI'
.UfLETE DSKILNON1H.ceL,OS~ILNON]H.RtL
r11e, del.t.dl
LNON1H,C8L
04 AIOCK' tre,td
L~{1N1H,PlL

<)3 BlOCkS freed

.J(JOe/BATCH
[LGIAJL Another jOb l' .tll1 lOQOtd-1n under t27,5107JJ
49 uler BROWN,E t27,$10 7 1
L,oQQed.off TTY511 .t 13142.43 on 2-AUg-'S
Runtl~.1 0100102, KCSlll, Connect tim •• 0100'51
nl.K·~tad.a1168, Write.lllS
JOb

5-19

GLOSSARY

Term

Definition

ALGOL

ALGOrithmic Language. A scientifically oriented
language that contains a complete syntax for
describing computational algorithms.

Alphanumeric

Any of the letters of the alphabet (uppercase A
through Z and lowercase a through z) and the
numerals (0 through 9).
'

ASCII Code

American
Standard
Code
for
Information
Interchange.
Its 7-bit code is used to create a
series of alphanumeric or special symbols.

Assemble

To prepare a macpine-language program from a
symbolic-language
program
by
substituting
absolute opera~ion codes for symbolic operation
codes and absolute or relocatable addresses for
symbolic addresses.

Assembler

A program which accepts symbolic code
and
translates it into machine instructions, item by
item. The assembler for TOPS-IO is called the
MACRO assembler.

Assembly Language

The
machine-oriented
symbolic
programming
language.
The assembly language for TOPS-IO is
MACRO. MACRO statements are equivalent to one
or more machine instructions.

Assembly Listing

A printed list which is the byproduct of an
assembly run.
It lists in logical-instruction
sequence all details of a routine showing the
symbolic
notation
next
to
the
actual
instructions generated by the assembler.

BASIC

Beginner's All-purpose
Symbolic
Instruction
Code.
A
timesharing
computer programming
language that is used for direct communication
between terminals and computer centers. BASIC
employs English-like terms, is relatively easy
to use, and has a wide range of applications.

Batch Processing

The technique whereby a computer executes one or
more programs in your absence.

C~d

A punched card with
80
vertical
columns
representing 80 characters.
Each column is
divided into two sections, one with character
positions labeled 0 through 9, and the other
with positions 11 and 12.
The 11 and 12
positions are not labeled and are also referred
to as the X and Y zone punches, respectively.
Glossary-l

Definition

Term
Card Column

One of the vertical lines of punch positions
a punched card.

Card Field

A fixed number of consecutive card
assigned to a unit of information.

Card Row

One of the horizontal lines of
on a punched card.

Central Processing
Unit (CPU)

The portion of the computer that contains the
arithmetic, logical, control, and I/O interface
circuits.

Character

One symbol of a set of elementary symbols such
as
those
corresponding to the keys on a
typewriter. The symbols usually include the
decimal digits 0 through 9,
the letters A,a
through Z,z, punctuation
marks,
a
space,
operation symbols, and any other special symbols
which a computer may read, store, or write.

COBOL

COmmon Business Oriented Language.
source language widely used in
commercial applications.

A high-level
business and

Command

An instruction that causes the
execute a specified operation.

computer

Compile

TO produce a machine- or intermediate-language
routine from a routine written in a high-level
language.
A
high-level
language
is
user-oriented and one in which single statements
may result in more than one machine-language
instruction, e.g., FORTRAN, COBOL or ALGOL.

Compiler

A system program which translates a high-level
source language into a language suitable for a
particular machine.
A compiler converts
a
source-language program into intermediate- or
machine-language.
Some
compilers
used
on
TOPS-IO are: ALGOL, COBOL, FORTRAN.

Computer

A device with self-contained memory capable of
accepting
information,
processlng
the
information, and outputting results.

Computer Operator

A person who has access to all software elements
of a system and performs operational functions
such as:
loading a tape transport, placing
cards in the card reader input hopper, removing
printouts from the printer rack, etc.

Continuation Card

A punched card which contains information
was started on a previous punched card.

that

Control File

The file made by you that directs Batch
processing of your job.

the

CPU

See Central Processing Unit.

Glossary-2

punch

columns
positions

Definition

Term
Cross-Reference
Listing

A printed listing that identifies each reference
of an assembled program with a specific label.
This listing is provided immediately after a
source program has been assembled.

Data

A general term used to denote any or all
numbers, letters, and symbols, or facts that
refer to or describe an object, idea, condition,
situation, or other factors.
It represents
basic elements of information which can be
processed or produced by a computer.

Debug

To locate and correct any mistakes in a computer
program.

Disk

A form of a mass-storage device in
information is stored in named files.

Execute

To interpret
instructions
operation(s).

File

An ordered collection of 36-bit words composing
computer instructions and/or data. A file can
be of any length, limited only by the available
space on the storage device and your maximum
space allotment on that device.
.

Filename

A name of I to 6 alphanumeric characters
by the user to identify a file.

File Extension

A string of I to 3 alphanumeric characters,
usually
chosen
to
describe
the kind of
information in a file. The file extension must
be separated from the filename by a period,
e.g., FOROI.DAT.

FORTRAN

FORmula
TRANslator.
A
procedure-oriented
programming
language that was designed for
solving scientific problems.
The language is
widely
used in many areas of engineering,
mathematics,
physics,
chemistry,
biology,
phychology,
industry,
the
military,
and
business.

Job

The entire sequence of tasks performed between
login and logout at an interactive terminal,
with a card deck, or at an operator's console.

Label

A symbolic name used to identify a statement in
the control file or in a magnetic tape file or
in a volume.

Log File

A file into which Batch writes a record of your
entire job.
This file may be printed as the
final step in Batch's processing of a job.

MACRO

See Assembly Languageo

Mounting a Device

A request
operator.

an
and

assign

Glossary-3

instruction
or
perform
the

I/O

device

which

set
of
indicated

chosen

via

the

Term

Definition

Object Program

The program which is the output of compilation
or assembly.
Often the object program is a
machine-language program ready for execution.

Password

The secret word assigned to you that, along with
your
project-programmer
number,
uniquely
identifies you to the system.

Peripheral Device

Any unit of equipment, distinct from the central
processing unit, which can provide the system
with outside storage or communication.

PPN

See Project-Programmer Number.

Program

The complete sequence of machine instructions
and routines necessary to resolve one or more
computational tasks.

Programming

The science of translating a problem from its
physical
environment to a language that a
computer can understand and obey~
also, the
process of planning the procedure for solving a
problem. This may involve, among other things,
the analysis of. the problem, preparation of a
flowchart, coding of the problem, establishing
input-output formats, establishing testing and
checkout procedures, allocation of
storage,
preparation of documentation, and supervision of
the running of the program on a computer.

Project-Programmer
Number

Commonly referred to as PPN, these two numbers
separated by a comma (,) identify you and your
file storage area on a file structure.

Queue

A list of jobs to be scheduled or run according
to
system-,
operator-,
or
user-assigned
priorities. For example, the Batch input queue
is the list of jobs to be processed by Batch.

Software

The totality of programs and routines used by a
computer.
Examples
include
compilers,
assemblers, operator programs, service routines,
utility routines, and subroutines.

Source Deck

A card deck that constitutes a computer
in symbolic language.

Source Language

The original form in which a program is prepared
prior to its processing by the computer to
produce the object-language program.

Source Program

A computer program written in
a
language
designed for humans to use to express procedures
or
problem
formulations.
A
translator
(assembler, compiler, or interpreter) is used to
translate the source program into an object- or
machine-language program that can be run on a
computer.

System

The collection of programs which
controls the computing facility~

Glossary-4

program

schedules

and

Term

Definition

System Command

An instruction to the system to perform an
operation.
The system commands for the TOPS-IO
are described in the DECsystem-lO
(TOPS-IO)
Operating System Commands Manual.

System Program

A program
generally
available
to
users,
administrators, or operators fo! performing some
specific function.
Examples are a
FORTRAN
compiler or a text editor.

Terminal

A device containing a keyboard,
similar
to a
typewriter,
and a printing or display mechanism
employed to establish communications with a
computer.

Glossary-5

INDEX

character, 2-3, 3-2
$ character, 3-2
% character, 2-10
* character, 2-3, 3-2
- character, 3-2
. character, 2-3, 3-2
character, 2-11, 2-12,
3-4
character, 2-3
~C characters, 2-4
~[ characters, 2-4

$-language card, 3-1, 3-7,
3-8
$-language card examples,
3-9

/AFTER: switch, 2-6, 3-3
ALGOL, Glossary-l
$ALGOL card, 3-7, 3-8
ALGOL example,
card, 5-10
$DATA, 3-14, 3-15, 3-16
terminal, 5-1, 5-2, 5-3
Alphanumeric, Glossary-l
ASCII Code, Glossary-l
Assemble, Glossary-l
Assembler, Glossa-y-l
Assembly Language, Glossary-l
Assembly Listing, Glossary-l

.BACKTO command, 2-12
.BACKTO label, 2-12
BASIC, Glossary-l
BASIC example,
card, 5-11, 5-12, 5-13
terminal, 5-4, 5-5
BASIC program card deck,
3-24, 3-25
Batch,
commands, 2-8
common tasks with, 5-1,
5-10
control card commands,
3-2
definition, 1-1
how to use, 1-2
output, 4-1, 4-2
submitting the job to,
2-5

Batch jobs,
cards, 3-1
terminal, 2-1
Batch Processing, Glossary-l

Card, Glossary-l
$-language, 3-1, 3-7, 3-8
$ALGOL, 3-7, 3-8
$COBOL, 3-7, 3-8
$CREATE, 3-1, 3-5, 3-6
$DATA, 3-1, 3-10, 3-11
$EOD, 3-1, 3-16
$EOJ, 3-1, 3-5
$ERROR, 3-1, 3-18, 3-19
$EXECUTE, 3-1, 3-9
$FORTRAN, 3-7, 3-8
$JOB, 3-1, 3-2, 3-3
$MACRO, 3-7, 3-8
$NOERROR, 3-1, 3-18, 3-19
$PASSWORD, 3-1, 3-5
$TOPSlO, 3-1, 3-16, 3-17
Card ALGOL example, 5-10
Card BASIC example, 5-11,
5-12, 5-13
Card COBOL example, 5-16,
5-17, 5-18, 5-19
Card Column, Glossary-2
Card deck,
BASIC program, 3-24, 3-25
program, 3-20, 3-21
setting up your, 3-20,
3-21
using GOTO statement,
3-30, 3-31
using TOPS-IO commands,
3-18
Card decks for programs,
3-23
Card Field, Glossary-2
Card format conventions,
3-2
Card FORTRAN example, 5-14,
5-15
Card job,
output from a, 4-4, 4-5
Card-reader file,
reading from, 3-12
Card Row, Glossary-2
Cards,
control, 3-22
control file from, 3-21
enter jobs with, 3-1,
5-10 to 5-18
nonspecial control, 3-23

Index-l

INDEX (Cont.)

Central Processing Unit,
Glossary-2
Character, Glossary-2
1, 2-3, 3-2
$, 3-2
%, 2-10
*, 2-3, 3-2
3-2
., 2-3, 3-2
., 2-11, 2-12, 3-4
=, 2-3
Characters,
"c, 2-4
" [, 2-4
COBOL, Glossary-2
$COBOL card, 3-7, 3-8
COBOL example,
card, 5-16, 5-17, 5-18,
5-19
$DATA, 3-12, 3-14
terminal, 5-7, 5-8, 5-9
Command, Glossary-2
. BACKTO , 2-12
.ERROR, 2-9, 2-10
.GOTO, 2-11, 2-13
.IF, 2-9
. IF (ERROR), 2-9
.IF (NOERROR), 2-9
.NOERROR, 2-10, 2-11
SUBMIT, 2-5
Commands,
Batch, 2-8
Batch control card, 3-2
in the control file,
3-21
system, 3-16
TOPS-lO, 2-2, 3-18
Common tasks with Batch,
5-1, 5-10
Compile, Glossary-2
Compiler, Glossary-2
Compiling a program, 3-7
Computer, Glossary-2
Computer Operator, Glossary-2
Continuation Card, Glossary-2
Control card commands,
Batch, 3-2
Control cards, 3-22
Batch, 3-2
nonspecial, 3-23
Control file, Glossary-2
commands in the, 3-21
creating a, 2-1, 2-2,
2-3, 3-21
error recovery, 3-26
example, 2-13
file format, 2-3
from cards, 3-21
Control-filnam.ext, 2-5

Conventions,
card format, 3-2
in this manual, v
CPU, Glossary-2
$CREATE card, 3-1, 3-5, 3-6
$CREATE examples, 3-7
Creating a control file,
2-1, 2-2, 2-3, 3-21
Creating a card file,
3-5, 3-6
Cross-Reference Listing,
Glossary-3

Data, Glossary-3
executing with, 3-10
$DATA ALGOL example, 3-14,
3-15, 3-16
$DATA card, 3-1, 3-10, 3-11,
3-14
$DA~A COBOL example, 3-12,
3-14
$DATA examples, 3-11
Data files,
naming, 3-14
$DATA FORTRAN example, 3-13,
3-15
Data input,
terminal, 3-25
Debug, Glossary-3
Disk, Glossary-3

End-of-data input, 3-16
Ending a job, 3-5
Enter jobs through terminal,
2-1, 5-1 to 5-9
Enter jobs with cards, 3-1,
5-10 to 5-18
$EOD card, 3-1, 3-16
$EOJ card, 3-1, 3-5
$ERROR card, 3-1, 3-18, 3-19
.ERROR command, 2-9, 2-10
Error recovery, 1-3, 3-18,
3-19, 3-27, 3-31
Error recovery,
control file, 3-26
program, 3-28, 3-29
specifying, 2-12, 2-13,
2-14, 3-26
.ERROR statement, 3-26
Example,
card ALGOL, 5-10
card BASIC, 5-11, 5-12,
5-13
card COBOL, 5-16, 5-17,
5-18, 5-19

Index-2

INDEX (Cont.)

Example (Cont.)
card FORTRAN, 5-14, 5-15
control file, ,2-13, 2-14
$DATA ALGOL, 3-14, 3-15,
3-16
$DATA COBOL, 3-12, 3-14
$DATA FORTRAN, 3-13, 3-15
terminal ALGOL, 5-1, 5-2,
5-3
terminal BASIC, 5-4, 5-5
terminal COBOL, 5-7, 5-8,
5-9
terminal FORTRAN, 5-6
Examples,
$-language card, 3-9
$CREATE, 3-7
$DATA, 3-11
Examples of submitting jobs,
2-7, 2-8
Execute, Glossary-3
$EXECUTE card, 3-1, 3-9
Executing a program, 3-9
Executing with data, 3-10

File, Glossary-3
creating a card, 3-5, 3-6
File-control switches, 2-5 q
2-7
Filename, Glossary-3
Filename.ext, v, 3-6, 3-11
File extension, Glossary-3
Format,
control card, 3-2
control file, 2-3
FORTRAN, Glossary-3
$FORTRAN card, 3-7, 3-8
FORTRAN example,
card, 5-14, 5-15
$DATA, 3-13, 3-15
terminal, 5-6

General switches, 2-5, 2-6
.GOTO command, 2-11, 2-13
.GOTO label, 2-11, 2-12
GOTO statement, 3-30, 3-31

How to use this manual, iii
How to use Batch, 1-2

.IF command, 2-9
.IF (ERROR) command, 2-9

.IF (NOERROR) command, 2-9
.IF statement, 3-19
Interpreting your output,
4-1, 4-2

Job, Glossary-3
ending a, 3-5
output from your, 4-1
running your, 1-2
starting a, 3-2, 3-3
$JOB card, 3-1, 3-2, 3-3
Job to Batch,
submitting the, 2-5
Jobname, 2-5

Label p Glossary-3, 2-12
.BACKTO, 2-12
.. GOTO, 2 -11, 2 -12
Lines,
format of control file,
2-3
Log file, Glossary-3
Log-filnam.ext, 2-5

MACRO, Glossary-3
$MACRO card, 3-7, 3-8
/MAP switch, 3-10, 3-11
Mounting a device,
Glossary-3

Naming data files, 3-14
$NOERROR card, 3-1, 3-18,
3-19
.NOERROR command, 2-10,
2-11
/NOLIST switch, 3-8
Nonspecial control cards, 3-23

Object Program, Glossary-4
Output,
Batch, 4-1, 4-2
from a card job, 4-4, 4-5
from a terminal job, 4-2,
4-3
interpreting your, 4-1
receiving your, 1-3
sample Batch, 4-2

Index-3

INDEX (Cont.)

/PAGE: switch, 2-6
/PAGES: switch, 3-3
Password, Glossary-4, 3-5
$PASSWORD card, 3-1, 3-5
Peripheral device,
Glossary-4
PPN, Glossary-4
/PRINT switch, 3-6
Printed output, 4-2
Program, Glossary-4
card decks for a, 3-20,
3-21, 3-23
compiling a, 3-7
error recovery, 3-28,
3-29
executing a, 3-9
Programming, Glossary-4
[proj,prog], v, 3-3,
Glossary-4
Project-Programmer Number,
Glossary-4

Queue, Glossary-4
Queue-operation switches,
2-5

Reading from card-reader
file, 3-12
Receiving your output, 1-3
Recovery,
error, 1-3, 2-12 to 2-14,
3-18, 3-19, 3-26 to 3-31
Recovery program,
error, 3-28, 3-29
Running your job, 1-2

Setting up your card deck,
3-20, 3-21
Software, Glossary-4
Source Deck, Glossary-4
Source Language, Glossary-4
Source Language, Glossary-4
Specifying error recovery,
2-12, 3-26
Spooled card-reader file,
3-12
Starting a card job, 3-2,
3-3
Statement,
.IF, 3-19
SUBMIT command, 2-5

Submitting the job to Batch,
2-5
examples of, 2-7, 2-8
Summary of Batch process,
1-3
/SUPPRESS switch, 3-6, 3-9,
3-11, 3-17
Switch,
/AFTER:, 2-6, 3-3
/MAP, 3-10, 3-11
/NOLIST, 3-8
/PAGE:, 2-6
/PAGES:, 3-3
/PRINT, 3-6
/SUPPRESS, 3-6, 3-9, 3-11,
3-17
/TIME:, 2-6, 3-4
/WIDTH:, 3-6, 3-8, 3-11,
3-17
/switches, 2-5, 3-3, 3-6,
3-8, 3-11, 3-17
Switch categories,
file-control, 2-5, 2-7
general, 2-5, 2-6
queue-operation, 2-5
System, Glossary-4
System Command, Glossary-5
System commands, 3-16
System Program, Glossary-5
System program output, 4-1

Terminal, Glossary-5
enter jobs through,
5-1 to 5-9
Terminal ALGOL example, 5-1,
5-2, 5-3
Terminal BASIC example, 5-4,
5-5
Terminal Batch jobs, 2-1
Terminal COBOL example, 5-7,
5-8, 5-9
Terminal data input, 3-25
Terminal FORTRAN example,
5-6
Terminal job,
output from a, 4-2, 4-3
/TIME: switch, 2-6, 3-4
TOPS-IO commands, 2-2, 3-18
$TOPSIO card, 3-1, 3-16,
3-17

/WIDTH: switch, 3-6, 3-8,
3-11, 3-17

Index-4

Getting Started With
Batch (TOPS-IO)
AA-D303A-TB
READER'S COMMENTS

NOTE:

This form is for document comments only.
DIGITAL will
use comments submitted on this form at the company's
discretion.
If you require a written reply and are
eligible to receive one under Software Performance
Report (SPR) service, submit your comments on an SPR
form.

Did you find this manual understandable, usable, and well-organized?
Please make suggestions for improvement.

m
o
o
c

Did you find errors in this manual?
page number.

If so, specify the error and the

Please indicate the type of reader that you most nearly represent.
[] Assembly language programmer
[] Higher-level language programmer
[] Occasional programmer (experienced)
[] User with little programming experience
[] Student programmer
[] Other (please specify) _______________________________________

Name

Date _________________________

Organization __________________________________ Telephone ____________________
Street ________________________________________________________________________
City_______________________

State _____________ Zip Code ______________
or
Country

----~-.--0
00

o
id

mN.ot gTear

FOa "oere and Tape - - - - - - - - - - - - - - - - - - - - - -

ffl-Il1--------~~;:.;;~~ --

I
I
I
I
I
I

if Mailed in the
United States

BUSINESS REPLY MAIL
FIRST CLASS PERMIT NO. 33 MAYNARD MASS.
POSTAGE WILL BE PAID BY ADDRESSEE

SOFTWARE PUBLICATIONS
200 FOREST STREET MR1-2/E37
MARLBOROUGH, MASSACHUSETTS 01752

- - - - - -

Do Not Tear - Fold Here and Tape - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

I
I
I
I
I
I
I
I

1....o
Q

til

o
:(

....:s

Co)