PUSHJ, PUSHJ, POPJ P,
JRST . + 1203

pushjay, pushjay, popjay pee
Jrst to point plus twelve oh three

PUSHJ is the recursive subroutine call, POPJ is the return therefrom, both require the stack register to be stipulated.

JRST is the unconditional jump instruction, and "." ("point") is the current address.

The point of 1203 being that it's a pretty random place in memory that's really unlikely to have code starting there that makes any sense.

int o1[];
o1 = -3;
*o1;

From Dennis_Tapes/dmr/cgd/cg1.c:expr.

It probably didn't help that this was a time prior to formal programming courses so a lot of programmers were self-taught and developed their craft in isolation (and often in assembler) so using "go to"s and ALTERs came pretty naturally.

IOWs, if you wanted a language that appealed to the masses at the time then you pretty well had to include goto and ALTER.

** https://en.wikipedia.org/wiki/Structured_programming#Debate

This one reassigns the address of an array, `int nlist[250]`, in char increments. Arrays are no longer lvalues, so this doesn't work anymore. Also, the address is unaligned every other iteration.

lbp;
nlist[250];

getnam()
{
extern nlist, lbp;
char nlist[], lbp[], c;

loop:
c = *lbp++;
if (c==';' | c=='\n')
goto el;
*nlist++ = c;
goto loop;
el:
*nlist++ = '\0';
}

Somewhat simplified from Dennis_Tapes/dmr/cgd/cg1.c:getnam.

I'm reminded of the MIT PDP-6 assmbler poem:

PUSHJ, PUSHJ, POPJ P,
JRST . + 1203

" like kicking dead whales down the beach."

Hmm. I used BCPL on Tenex in 1980, and don't remember having problems.

And my dad had a PDP-7 at work. This one.

FAF_PDP7web.jpg by David in Tokyo

PBase (pbase.com)

The earliest extant C compiler is last1120c from July 1972, the last C version for the PDP-11/20, before they migrated to the PDP-11/45. This version still has the label lvalue behavior of B seen in cvft. Then, it was changed to the modern behavior by the time of prestruct-c from December 1972. That version supports structures, but does not yet use them itself.

All three can be found in Dennis_Tapes: https://www.tuhs.org/Archive/Applications/Dennis_Tapes

It started as B, an untyped and interpreted language that only had one kind of value, a word. This was a perfect fit for the PDP-7 that UNIX started on, with 18-bit words, but as they transitioned to the PDP-11, with 16-bit words and 8-bit addressing, this became a limitation.

Soon, types were added, to distinguish char, int, and pointers, and it became known as NB ("New B"). But, B wasn't particularly fast, as it was interpreted (well, threaded).

Once it was rewritten to be compiled, the language became known as C (perhaps initially as NC). For a short while, everything in C was an lvalue like B, giving the above snippet, but this was dropped a few months later, presumably for efficiency.

Some UNIX utilities had been written in B/C from the start, but efforts to rewrite the kernel itself in B/C had failed. Finally, once structs were added to C, it was powerful enough to support the kernel and it was rewritten in C over the summer of 1973, culminating in the release of UNIX V4.

#c #unix #retrocomputing #vintagecomputing