SSPS-2 original, cbn
SSPS Deck 2
FROM: Ralph Reinke
TO: Paul Pierce
DATE: 14th of August 1998
RE: Contribution to the 1401 Software Project
-----------------------------------------------
AIM:
---
Three 1401 machine programs are handed over to be saved for any
present or future 1401 enthusiasts. One of the programs is a small
storage print utility, the other two being card based assembler
that were the programming tools of the time.
Covered in this document is everything needed to study or really
operate these programs. Also the manner in which the programs are
stored in this package is explained. It is not intended to explain
and describe the 1401 machine. A very few details about the machine
are given as needed for understanding the operating procedures.
1401 CONFIGURATION:
------------------
The minimal configuration has been the CPU 1401 of any size, the
combined card reader and punch unit 1402 and the printer 1403.
The programs here delivered are meant for this basic configuration
and do not need anything else. Core storage sizes are mentioned
where needed. Of course the assemblers are able to build programs
for any configuration including magnetic tapes and disks.
STACKERS / SWITCHES / HALTS:
---------------------------
The following few details about the 1401 are needed to be known
as they always showed up in the operating procedures for programs
of any complexity.
* STACKERS
The 1402 unit had the card punch on the left, the reader on
the right and in between there were five adjacent compartments
or 'stackers' to place the cards that had been read or punched.
These stackers were named in the following manner:
(Punch) N/P 4 8/2 1 N/R (Reader)
If not ordered otherwise by program control all cards punched
would go into N/P (Normal Punch) and all cards read into N/R
(Normal Read). Cards punched could optionally be directed into
4 or 8/2 and cards read into 1 or 8/2.
In this manner the card input and output could be split by
sending them into different stackers.
* SWITCHES
On the main panel of the CPU a row of switches named A through
G could be toggled up and down (ON and OFF) and the position of
these switches could be sensed by program instructions. Hereby
any number of different program behaviour could be offered and
chosen. - Switch A had a special meaning: when set to ON it was
sensed as ON only when the LAST CARD of the input batch had
passed the reader.
* HALTS
A special instruction HALT when encountered during program flow
would stop the CPU and the red STOP key on the panel lighted.
The instruction was either coded with no operand, a number of
choice or a valid branching address. Accordingly the following
differing behaviour resulted:
NO OPERAND: Instruction Register I shows address of the Next
Sequential Instruction (NSI). Pressing START key
starts the CPU on NSI. NSI identifies a HALT in
case there is more than one HALT in a program.
This is documented in the operating papers with
its meaning.
NUMBER: Register A for the A-Operand shows the number and
thereby identifies a HALT. Pressing START starts the
CPU on NSI.
ADDRESS: On pressing START the CPU branches to the coded
address. The HALT instruction may point to itself
thereby locking the program totally. The display
of NSI in the I-Register identifies the HALT.
By combining stackers, switches and halts in a program it is
possible to build any optional program behaviour.
LOADING PROGRAMS:
----------------
The 1401 never had any Operating System however simple. While
programs could reside on magnetic tape and be loaded from there
the basic procedure was to have the programs as punched cards, the
input data for the program also consisting of cards. The program
cards followed by the input cards were placed into the reader and
a lid on top of the last card to secure the proper feeding without
damaging the last cards.
On pressing the START key on the panel the CPU automatically started
the card reader. The program cards were read into core storage and
the last program card initiated program execution. The cards of the
machine program had quite an involved structure which to explain
would need to go into very much detail of the CPU's principles of
operation. Some basic information about this will be given further
down in connection with documenting one of the assemblers.
FIXED STORAGE AREAS:
-------------------
The 1401 had a few areas of low storage that were assigned to the
following special purposes and addresses:
* Card Input Area = 1 - 80
* Card Punch Area = 101 - 180
* Print Area = 201 - 332
Three Index Registers were incorporated as parts of main storage
at the following addresses:
X1 = 087 - 089, X2 = 092 - 094, X3 = 097 - 099
DEBUGGING OF PROGRAMS:
---------------------
The debugging procedure for programs mainly consisted of printing
the contents of the main storage after program crash and taking
this 'storage dump' back to your desk for analysis. This printout
could be effected in two ways: by hardware or by software.
The panel of the CPU had switches and keys for effecting a trap
for an instruction address, restarting the stopped CPU on any
desired instruction address, single step mode of operation and
last not least the choice of printing any desired 100 bytes of
storage, named a 'Line' of storage.
Printout was in a crude manner without any layout and any 'Line'
had to be printed by separate handling of switches. The strength
of this hardware approach was that no storage or register contents
was altered by this method. By the way: storage consisted of those
matrices of magnetized ferrite rings the magnetism of which held
the stored data for any length of time after a program run even
when the CPU was powered down and up again!
The software approach of course was to have a utility program for
printing storage. Such a program was started by START after crash
of the faulty program and delivered a nicely made up 'storage dump'
of the whole storage. The drawback was that the utility, though
being small, by being loaded destroyed some contents beginning at
address zero. Whenever these locations were of importance for the
debugging case in question one simply 'dumped' the first lines by
hardware and then loaded the utility.
PROGRAM 1 of 3: STORAGE PRINT UTILITY:
=====================================
The utility program consists of only 16 cards and is found in the
file 'DUMP' in this package. The operating procedure is nothing
more than starting the program by START. This program managed to
only destroy the contents of the Card Input Area. The effected
printout shows the following details:
* Contents of Print Area
* Contents of Index Registers
* Contents of Punch Area
* The following parts of storage are shown separated per Line
with Line numbering, beginning with two printed lines as a
scale for better reading, followed by the line with storage
contents and a closing line of scattered blanks and '1' by
which the current location of 'Word Marks' were shown. These
Word Marks are an allimportant special feature of the 1401
that cannot here be explained in a few words. - In conclusion
the actual settings of Switches A,B...G were given.
Lines of storage containing spaces only are not displayed.
As this program was delivered in Germany the following few German
words appear in the printout and their English meaning is:
LINIE = LINE, UMSCHALTER = SWITCH, EIN = ON, AUS = OFF.
ASSEMBLERS FOR THE 1401:
-----------------------
There were two different systems of assembly language. AUTOCODER
was the more modern and progressive system offering a flexible
input format and even macros and other prebuilt routines. The
assembler and its library resided on magnetic tape. The assemblers
in this package belonged to the 'Symbolic Programming System' or
SPS, the more basic method restricted to punched cards as storage
medium. No macro feature was available and a rigid input format
had to be observed. The strength of the system was the fact that
almost any poor hardware configuration was sufficient.
The SPS showed up in two steps of evolution. The first came as SPS1
and SPS2, the second being called SSPS (probably meaning SUPER SPS).
While SPS1 even worked on a CPU with only 1400 bytes of storage it
was capable of building programs of no greater size than 4000 bytes.
SPS2 needed a storage size of 4000 and could manage programs of the
maximum size of 16000 bytes. SPS1 and SPS2 consisted of 5 programs
each and the operating procedure was quite involved.
SSPS in contrast needed at least 4000 bytes and was delivered tailor
made for each existing storage size. It was composed of 2 programs
only and offered a much simpler and quicker procedure.
INPUT FORMAT FOR THESE ASSEMBLERS:
---------------------------------
The layout for the input cards for SPS and SSPS - the symbolic
program cards - is identical. The meaning of the 80 collumns is:
* 01-05 = Card numbering without duplicates and in ascending
order, best with gaps for insertions.
* 06-07 = Count = number of characters, only used for definition
of constants and areas.
* 08-13 = Label if needed.
* 14-16 = Operation Code.
* 17-27 = A-Operand, subdivided as follows:
* 17-22 = Address in form of a Label or expressly given
as a number of 4 digits.
* 23 = Optional Sign '+' or '-' for an Address Calculation,
Blank can mean '+'.
* 24-26 = Address Calculation, optional as a 3-digit number
meaning an increment or decrement for Address.
* 27 = Optionally chosen Index Register '1'/'2'/'3'.
* 28-38 = B-Operand, subdivided like A-Operand.
* 39 = Operation Supplement where needed.
* 40-55 = Comments.
* 56-75 = Unused.
* 76-80 = Program Identification of free choice.
PROGRAM 2 of 3: ASSEMBLER SPS2:
==============================
This assembler comes in 5 parts which mean a logical unit but in a
technical sense they are 5 separate machine programs. To a minor
degree they can be used separately. These programs are found in the
the following files: SPS2-1, SPS2-2, SPS2-3, SPS2-4 and SPS2-5.
These names will also be used as an abbreviation in the folllowing
explanations.
The shortage of the very expensive core storage enforces a splitting
of the assembly process and the following five steps result:
PRELIST - ASSEMBLY PHASE 1 - ASSEMBLY PHASE 2 - POSTLIST - CONDENSE
PRELIST: First it must be made sure the symbolic program cards do
------- not contain any formal errors for otherwise the assembly
proper would never be possible. Therefore program SPS2-1
has to be started first, followed by these cards:
1) A special Control Card telling the assembler the storage
size of the system used in this assembly and the storage
size of the system the resulting machine program is meant
for, which of course can and mostly will be identical.
The layout for this card is:
14-16 = 'CTL'
17 = storage size of assembly machine
18 = storage size of target machine
The sizes are given as the following numbers:
3 = 4.000 bytes
4 = 8.000 bytes
5 = 12.000 bytes
6 = 16.000 bytes
2) Another Control Card which is optional and can alter the
Origin Address of the program in storage. If this card is
missing Origin is automatically set to 333 (immediately
following the Print Area). The Layout of the card is:
14-16 = 'ORG'
17-20 = Numerical Address in 4 digits.
3) The Symbolic Program cards following the SPS Layout.
Switch A must be set to ON when STARTing the program.
The run results in printing the PRELIST - meaning the
list before the assembly process. The input cards are
printed with header lines and the checking may reveal
the following errors:
ERR 1 = PAGE/LINE SEQUENCE
Card numbering out of sequence or missing.
ERR 2 = COUNT
1. Value in field is smaller 1 or greater 32.
2. Value in field is not numerical.
ERR 3 = LABEL
1. First character is blank, numerical, % or # or @
2. DS-Card without Label has no '*' in A-operand.
ERR 4 = MNEMONIC OP CODE
1. Invalid Symbolic Operation Code.
2. Symbolic Operation missing.
ERR 5 = A-OPERAND
1. Instruction has a B-Operand but no A-Operand.
2. A-Operand of a DCW-, DS-, DC- or DSA-Definition
is empty or contains symbolic entry.
3. A-Operand of ORG-Card with no numerical address.
4. A-Operand of EX-Card or END-Card contains '*'.
5. Some formal error in A-Operand:
1. INDEX, col. 27 neither empty nor '1'/'2'/'3'.
2. ADDRESS CALCULATION, col. 24-26, value not
numerical or not right justified.
3. SIGN, col. 23 not empty or '+'/'-'.
4. Empty position to the left of value.
5. Operand with %-character in most significant
position has more than 3 positions and so
does not mean an Input/Output Unit.
6. Left position of Operand is numerical while
the others are not.
7. Numerical Address with less than 4 digits.
8. Numerical Address exceeds storage capacity
given in col. 18 of CTL-Card.
9. A *-Address is not followed by spaces.
ERR 6 = B-OPERAND
Invalid B-Operand:
1. Col. 23 of a DCW- or DC-Card neither empty nor
does it contain '+'/'-'.
ERR 7 = COLS 56-74 NOT BLANK
Card not empty in cols. 56-74 which may lead to
faulty assembly.
In conclusion the following messages are printed:
* NO CONTROL CARD if CTL-Card is missing or not first card.
* NO END CARD if END-Card is missing or not last card.
* Total number of Labels.
* Highest storage address used.
* Number of input cards.
The cards of machine program SPS2-1 are directed to stacker
N/R, the symbolic program cards to stacker 1.
Programmed HALTS for SPS2-1:
Instruction Address Meaning
2376 Last Card, END OF JOB, pressing
START lets the loaded program
take a new run.
ASSEMBLY: The assembly is effected by machine programs SPS2-2 and
-------- SPS2-3 which belong together of necessity: SPS2-2 is an
EX-phase. The symbolic cards input steered to stacker 1
by SPS2-1 must be inserted between SPS2-2 and SPS2-3
and STARTed, Switch A remain set to ON.
The machine program cards of SPS2-2 go into stacker N/R,
the symbolic program cards into stacker 1. While SPS2-3
still remains in the reader SPS2-2 is working on phase 1
of the assembly process which gives the following results:
* Symbolic Operation Codes are translated into real ones.
* Addresses in storage are calculated and areas in
storage reserved for Instructions, Constants and Areas.
* A symbol table is built in main storage holding the
Labels and their real storage addresses calculated
for this program.
* Intermediate Cards are punched and directed to stacker
8. These cards hold information needed in phase 2 of
the assembly process. Each symbolic card of the input
is duplicated as an intermediate card and information
added, for instance the instruction lenght is placed
as COUNT into cols. 6-7.
If necessary corrections from diagnostics have been left
off or not been successful this phase 1 of assembly comes
to a programmed stop, the incriminated card being the last
one in stacker 1. Though there is a restart procedure for
going on after such a card has been corrected on the key
punch this is quite error prone and should be avoided in
favour of getting a complete OK from the Prelist SPS2-1.
Programmed HALTS for SPS2-2:
Instruction Address Meaning
0409 Invalid Operation Code in card last
read. Pressing START lets continue
without incriminated card. If card
is corrected and placed into reader
as first one pressing START will
include it.
1018 SPS2-2 or phase 1 is ended and card
just read was not recognized as the
first card of SPS2-3 or phase 2.
SPS2-3 can be placed into reader and
STARTed.
As soon as the END-Card from the input has been read this
phase 1 closes and SPS2-3 is loaded automatically from the
reader. If SPS2-3 has not yet been placed into the reader
the CPU is stopped showing the card read command '1' in
the OP-Register on the panel.
The Intermediate Cards of phase 1 are to be placed behind
SPS2-3 as its input and the START key pressed. The cards
of machine program SPS2-3 go into stacker N/R, the Inter=
mediate Cards into stacker 8/2 and these are useless after
this run and should be discarded. The result and output of
the run are the newly punched cards in stacker N/P which
now hold the following information:
* Again all the information from the Intermediate Cards
is copied.
* The Symbolic Instruction is fully translated into the
machine language and all symbolic addresses replaced
by real addresses using the symbol table in storage,
taking into consideration any Address Calculation and
wanted Index Registers from the symbolic code. Instead
of an Instruction the card could hold a Constant of
course.
* A LOAD instruction is tailored for the contents of the
card and added in cols. 56-74. This makes the card a
'selfloading card'.
On conclusion of the run the batch of cards in stacker N/P
is the ready to use machine program. Some further remarks
about the construction of this machine program will be in
place:
* Already at begin of phase 2 three additional cards
have been generated. They are very important and must
be seen as an integral part of the program though in
a strictly technical sense they are two additional,
separate programs themselves:
* The first and second of the three cards are a
stand alone program for completely clearing the
main storage to blanks and removing all Word Marks.
As the core storage holds all data from operation
indefinitely this step is necessary to bring well
defined conditions for a new program. The size of
storage area to be cleared is taken from col. 18
of the CTL-Card.
* The third card is the Bootstrap Card and needed
for preparing and initiating the Load procedure
for a program.
* All of the following cards each hold one Instruction
or one Definition of a Constant in machine language.
* As an exception the last card is the END-Card marking
the end of the machine program and it also holds the
Start Address of the program.
Now the process of Loading a program can be understood as
as a sequence of the following steps:
1) The CLEAR STORAGE program sweeps the floor for the
proper program execution.
2) The BOOTSTRAP program starts the following chain
of LOAD Instructions:
3) A card of the machine program proper is read and if it
is not the END-Card the LOAD Instruction in col. 56
is executed, the parameters of which which are:
* Address and length of the piece of machine code
in this card and
* the designated core storage address for it.
4) If the END-Card was encountered program control is
transferred to the Start Address of the program and
execution begins.
By this chain of LOADs the code fragments fly into place
like the pieces of a puzzle.
CAUTION: In order to make matters not too boring there can
be a certain complication. If the storage size of the
machine used for assembly is very restricted and/or the
symbolic program is very big in the sense of holding a
great number of Labels it can happen that the Symbol Table
that has to fit in storage besides the assembler program
is overflowed. This now does not mean that a program of
this size cannot be assembled on such a small machine. It
only means this cannot be done in one run. Surprisingly
the assembly process of phase 1 plus phase 2 as described
above can be repeated loopwise and the resolution of the
symbolic addresses is done incrementally! This means that
in all runs but the last the punched cards do not mean the
completed machine program but Intermediate Cards which are
the input for the next run and then discarded. - To judge
whether an assembly run of phase 1 plus phase 2 is the only
or concluding one there should be a message on the printer
and also the three additional cards mentioned above are
only punched in a concluding run. The following numbers
show the limits for storage sizes versus number of Labels
and that it is not a very like case to occur:
Storage Size Maximum Number of Labels
4.000 260
8.000 660
12.000 1060
16.000 1460
Programmed HALTS for SPS2-3:
Instruction Address Meaning
1197 END OF JOB.
POSTLIST: The name of the list again refers to the assembly itself
-------- and means a listing taken after assembly. The machine
program produced by SPS2-2 plus SPS2-3 is used for input
when running SPS2-4 to print the Postlist. There is no
special operating procedure to be observed: switch A must
as usual be set to ON and after placing SPS2-4 into the
reader followed by the machine program START is pressed.
The END-Card in input brings the run to a normal close.
This listing in addition to the symbolic code also gives
the resulting machine code for each statement. It is the
document to be kept and stored away for any program.
Rather unexpectedly this Postlist can reveal persisting
errors in the machine program or - more probably - that
a wrong deck of cards has been used for input. These are
the possible error messages:
* The special character 'lozenge' has been printed in
a line close to the statement numbering and can mean
one of the following cases:
* A symbol in an A-Operand or B-Operand has not
been defined as a Label.
* The Operation Code for an Instruction is missing.
* An address pointing into the Card Input Area has
been assigned to the data to be loaded from a card.
* The number of characters for a Constant exceeds 32.
* The collumns for COUNT in a card hold spaces/zero.
* On reading a card that does not contain machine code
it gets the remark 'UNASSEMBLED CARD'. This happens
with the wrong card deck as input or in case assembly
has not yet been completed (missing repetition of run).
* At last something can be wrong with the three special
cards that are normally added in front of the program
and the following messages can occur:
FIRST CLEAR STORAGE CARD MISSING
SECOND CLEAR STORAGE CARD MISSING
NO BOOTSTRAP CARD
Programmed HALTS for SPS2-4:
Instruction Address Meaning
1322 Last Card, END OF JOB. Pressing
START will let the loaded program
take a new run.
CONDENSE: As each card of the machine program as described up to now
-------- contains all the symbolic code as well as the machine code
of only one Instruction or Constant this offered - for the
very unafraid - the possibility to further correct and
patch a program on the key punch before running another
assembly. Such practices were suggested by the very narrow
time limits of having the machine free for testing.
Normally a machine program of this kind when ripe for
production would be too bulky to be handy. So the program
SPS2-5 was the concluding step as it condensed the machine
program from SPS2-3 by throwing out all symbolic code and
compressing as many machine code pieces into one card as
would go in. A new LOAD Instruction per card is formed and
so the quality of the cards as 'selfloading' upheld. The
process of program loading as described above remains
unchanged.
No special operating procedure is necessary: switch A must
be set to ON, program SPS2-5, followed by the uncondensed
machine program, placed into the reader and START pressed.
The input cards are directed to stacker 1, the output cards
to stacker N/P.
Programmed HALTS:
Instruction Address Meaning
1222 END-Card read, END OF JOB,
Pressing START can start new run
of loaded program with next card
deck from reader.
1323 Card last read is not an assembled
card. Pressing START will continue
with next card.
1327 Value in field COUNT of card last
read hold a value greater than 32
or smaller 1. Pressing START will
continue with next card.
PROGRAM 3 of 3: ASSEMBLER SSPS:
==============================
SSPS is a much improved version of SPS consisting of only two parts
here named SSPS-1 and SSPS-2. The operating procedure is much less
involved and the Intermediate Cards of SPS are done away with. The
steps of the assembly process as described for SPS are nevertheless
basically the same and only partially covered by integration.
SSPS assemblers were distributed as tailored for different storage
sizes and so the CTL-Control Card does not exist. The specimen here
given is meant for a machine with 8.000 bytes of storage.
The internal Symbol Table for Labels now takes into account the
varying length of Labels and so improves its working capacity. On
the other hand there is no possibility of incrementally working off
Labels in repeated runs - such cases are marked as ERROR 8 in the
Prelist.
The two parts or phases of SSPS belong to each other the first
being an EX-Phase and do not make any sense separately. The
machine program punched by phase 2 is always in condensed format.
The operating procedure is to place the symbolic program between
the two phases SSPS-1 and SSPS-2 sandwichlike, put this package
into the card reader, set switch A to ON and to press START.
The Prelist also informs about how many Labels have been stored
and how many more would probably be possible.
Programmed HALTS:
Instruction Address Meaning
0574 Phase 1 has been loaded and is ready to work.
Pressing START starts and a Prelist will be
printed. Pressing START-RESET, then START will
suppress the Prelist, only statements in error
will be printed.
0825 Phase 2 has been loaded and is ready to work.
Pressing START starts the assembly and prints
the Postlist. Pressing START-RESET, then START
starts the assembly without a Postlist. All
statements in error will be printed anyway.
The symbolic cards that have been read by
phase 1 must be taken from stacker 1 and be
placed into the reader again. The machine
program punched is steered into stacker 4.
1356 END OF JOB.
CAUTION: Before starting phase 2 there should always be checked for
serious errors in phase 1 which do not justify a full assembly and
may even crash phase 2.
HOW THE DESCRIBED PROGRAMS ARE STORED IN THEIR FILES:
----------------------------------------------------
Three levels of usage can be forseen for these programs. The modest
one will be to analyze them more or less for mere understanding. The
more ambituous approach would be to have a simulator or emulator
program for the 1401 and then the program files would have to be
somehow prepared or transformed as input. In the very rare case that
a real 1401 should be available the original punched cards would be
needed and reproduced from these files.
It has been tried to cover all three levels by the contents of the
files and their structure must of course be well understood.
The original punched cards from the 1401 environment were transferred
to 9-track tape on a mainframe /360 and carried along to /370 and
/390 for a long time, at last transferred to the PC.
There must be clarity about the different code schemes. The 1401
had its data in BCD or Binary Coded Decimal. For any possible value
there was a pattern of holes in the standard IBM punched card of 80
collumns and 12 rows. The following IBM mainframes use EBCDIC or
Extended Binary Coded Decimal Interchange Code - not ASCII like the
rest of the world! The denomination as Extended already says that
BCD is a subset of EBCDIC. Accordingly the 1401 punched cards could
be read and stored on tape without any problem and without being
altered thereby. Nevertheless the 1401 used some special graphic
characters that only showed up on the print chains of the 1403
and similar printers. So we have the problem that some values of
importance in an assembly listing can no longer be shown in print
by any typical printer - mainframe or PC. And then the PC files
have to be in ASCII of course.
To best solve or escape the problems the following has been done.
In any of the program files of this package each original punched
card is given as a sequence of 16 records of size 80 each. As an
example all of the characters that can directly be input from a
PC keybord have been turned into such a record group here:
1...5...10...15...20...25...30...35...40...45...50...55...60...65...70...75...80
ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 #&*,./<-% ()\@
CCCCCCCCCDDDDDDDDDEEEEEEEE4FFFFFFFFFF47556464664CDE74444444444444444444444444444
12345678912345678923456789001234567890B0CBB1C0C0000C0000000000000000000000000000
*********..............................*..*.*...*...............................
.........*********......................*....*...*..............................
..................********.*.............*.*..*.***.............................
*........*..................*..............*....................................
.*........*.......*..........*....................*.............................
..*........*.......*..........*.......*..**.....................................
...*........*.......*..........*........*...*.*....*............................
....*........*.......*..........*...............................................
.....*........*.......*..........*..............................................
......*........*.......*..........*.............................................
.......*........*.......*..........*..*.***.*.*...**............................
........*........*.......*..........*...........................................
The contents and meaning of the 16 records is the following:
* For better reading and separation each group begins with a scale
showing the positions of the 80 collumns.
* Next follows the original card contents turned to ASCII as best
as possible. But be careful - this is only an approximation for
the human reader! As said not all BCD values have their graphic
equivalent in ASCII and these cases are simply seen - or rather
not seen - as blank in this line. Also never to be forgotten:
this is ASCII and it would be unreliable to translate by program
from this line for any use by machine.
* The following two records or lines give the original contents
of the cards in HEXA. This is the reliable source where the
preceeding record fails. The first of the two records gives
the 80 ZONE parts of the 80 bytes X'* ' and the second of the
two the 80 DIGIT parts of the 80 bytes X' *'.
The proposed use of these two records is:
* Whenever the human reader sees a BLANK in the second record
he better makes sure whether a real BLANK is meant, namely
X'40' in EBCDIC as HEXA in the third and fourth record. Any
other HEXA value designates one of the queer 1401 BCD values
that cannot be shown as ASCII graphically.
* Whenever the programs shall be really used on a machine in
whatever mode for execution they should be transformed from
these two records of every group as the reliable data source.
* The remaining 12 records of a group simulate the original hole
pattern of the punched card, every '*' obviously meaning a hole.
The first of these 12 records is 'row 12' of the card, the next
'row 11' and then 0 through 9.
If the original cards are needed for a real 1401 they can be
reproduced on a key punch by hand along this card image.
As this would be an error prone and somewhat nerve-racking
procedure perhaps the following idea can be helpful. There
are ISA-Cards for PCs with relays for controlling external
events by a PC program. For a person with some electronic
experience it should not be difficult to somehow connect
such relays to the keyboard of a key punch and so control
it by PC. The ON/OFF nature of the card image given might
be easy to use as input for this control task.
--- FINIS ---
Back
Back to the Collection