🚀 go-pugleaf

In article <1990Jan22.152652.7636@virtech.uucp>, jje@virtech.uucp
(Jeremy J. Epstein) writes:

> [... about BCD overpunching on 026's...]

	The most useful BCD overpunch was record mark, 0-2-8.
	A single 1401 MCM instruction could move a variable
	length data record, terminated by a record mark.  This
	was essentially a hard-wired strcpy(), and was used
	heavily on card-to-tape and tape-to-print utility operations.

	A little-known feature of some early 709/7090 FORTRAN II
	compilers was that they recognized record marks to allow
	multiple statements per card.  For example, if "#" represents
	a record mark, they'd accept "I=0 # J=1 # K=2" on a single
	card.

> Does anyone out there remember the multi-punch sequences for the
> characters which weren't on the keyboard (no cheating by looking at
> old card decks)?  I think that "+" was 12-6-8, but I'm not sure.  I don't
> even remember what characters had to be multipunched besides +, (, )

	Actually + by itself was just a 12 punch.  Among the zone
	punches, + (12-zone) and - (11-zone) would be used in data
	for 1401 programs by overpunching the sign on the least
	significant digit of a number.  These were read in as the
	A and B bits that the 1401's hardware interpreted as
	a number's sign.

	   Related trivia:  The sign was over the least significant
	   (rightmost) digit because that's what would be addressed
	   in a 1401 instruction.  Something like an add would:

		--  Load the given addresses into the A & B address
			registers
		--  Fetch 1st byte of each, including sign
		--  For each byte until reaching one with a WM
			(word mark) bit set, add "*A" to "*B",
			then DECREMENT both address registers.

		i.e., it worked right-to-left, from the high-addressed
		end of a number toward the low-addressed end.  Number
		size was limited only by how much memory was available.

		This also allowed instructions to "chain" addresses,
		using the previous instruction's last A/B address register
		contents to define the next operand address.  A
		C-like equivaent would be something like this:

		    b[0] = a[0] + b[0]
		    +			/*  Adds a[1] to b[1]	*/
		    +			/*  Adds a[2] to b[2]	*/
		    +			/*  ... etc.		*/


----------------
Paul Raveling
Rave...@isi.edu