

    FROM: Ralph Reinke (101520.3451@compuserve.com)

    TO:   Paul Pierce (prp@teleport.com)

    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 ---



