IBM-1401 (original) (raw)
- IBM 1401 Data Processing System Reference Card,side 1,side 2.
- From Mike Albaugh
[re: Fortran Compilier for a 4 K character 1401]
I still have the "Internals" reference manual... :-) IIRC, it was derived from the 1401 compiler discussed in J.A.N. Lee's "Anatomy of a Compiler" book. That one had 63 phases. Note the terminology. A "pass" was used to refer to reading in (and writing out) the source code or a modified form of it. As used in the 1401 and 1130 compilers, a _phase_ was essentially an overlay of code. The first phase read the entire source into memory and built a partially tokenised form. Each successive phase "recognized" some particular construct and replaced it with some derivation. This might be, e.g. "recognize array references and convert to offset calculation", or "transform expressions to canonical form", or "emit object code for canonical-form expression".
The major "win" is that one is only reading (code overlays), not reading-writing, so file allocation issues don't arise. One could even do this technique from sequential storage (tape, or even cards). The major "lose" is that an entire source file must fit in core, along with the largest "phase", modulo a little wriggling about being able to use larger phases when the source is in a more "dense" form. In practice, with sane-sized modules, it worked. - from LaFarr Stuart FORTRAN Compilier (for 4K memory, card machines)
- The cards were stacked in the card reader hopper as follows:
- 30 to 50 cards (first pass?)
- your FORTRAN source deck
- about 3000 cards (more than a box) of maybe 60 passes of the FORTRAN compilier
- maybe 3 inches of utilities, including variable precision math functions- You pushed the LOAD button and stood back and watched
- the card reader would read cards at mostly 800 cards/minute
- there would be moments where the reader would miss a few cycles
- at the end of the reading of the big deck,
- the 1401 optionally would be running the compiled FORTRAN
- and usually the printer would start printing the results of the program.- ----
- 1st phase took out the spaces, and stored it in the top of memory, first card highest
- 2nd phase ?, looking for a "DO" loop, replacing with token, ...
- ....
- last phase picked up required subroutines, then go into execution - usually punching object included copying subroutines
- You pushed the LOAD button and stood back and watched
- The cards were stacked in the card reader hopper as follows:
An interesting verification routine,
- one coding sheet. Hilbert matrix, say 8x8 generate, invers, multiply invert by original, giving identy matrix.
- Required at least 12 digits to do reasonably, better than 360 and many other machines.
- Demo that worked on 1401 failed on most other machines. slick eh?
(Required double precission on other machines.)
LaFarr has a web page What makes the 1401 so interesting?
and from LaFarr - Feb 2007 -
Hi: It is only academic, but I thought the clear word mark switch could be used following any 7 character instruction such as Move, Load, Add, Subtract, etc. I am 99% certain we allowed it in the RCA emulators, and simulators. Of course I am biased, but I believe RCA had better emulators/simulators than anyone else, we even made sure that non numeric characters added produced true "1401" results.
Unfortunately RCA's peripherals didn't produce true "1401" results. Even when they worked right! :-( We had no way to "stacker select" such as merge "in the middle pocket" cards from the punch and reader. Hence we made no effort to make stacker select work correct based on the time it was issued after a read/punch. (Essentially; on a real 1401, a multiply or divide instruction before a stacker select would take enough time to cause the stacker select to be ignored. But we all know timing dependent coding rarely works on simulators. I wish I knew more about IBM's emulators on the Model 30's and 40's worked on some of these questionable techniques. I know in the early days a lot of 30's spent a lot of time running 1401 programs.) - In comp.lang.asm370, Clark F. Morris, Jr. wrote
The names "Symbolic Programming System" and "Autocoder" were given to IBM assemblers for a number of unrelated pre-360 machines. These were assemblers in the modern sense, in that they allowed symbolic reference to program locations and data areas. On machines like the 1401 in which there were both SPS and Autocoder assemblers, Autocoder was the more elaborate one.
1401 SPS was very simple, requiring symbolic operands to be in fixed-format fields of its input records and explicit coding of d-modifier characters, but these limitations allowed it to run in a minimal, 1400-character 1401.
1401 Autocoder was a little more programmer-friendly, with comma-delimited operands, extended branch mnemonics with assembler-generated d-modifiers, and a simple macro facility, but it required a 4000-character 1401.