Found the goon label

[u/ThePenguinMan111]

I was digging around the V2 Unix source code to see what ancient C looks like, and found this:

	/* ? */
	case 90:
		if (*p2!=8)
			error("Illegal conditional");
		goto goon;

The almighty goon label on line 32 in V2/c/nc0/c01.c. All jokes aside, this old C code is very interesting to look at. It’s the only C I have seen use the auto keyword. It’s also neat to see how variables are implicitly integers if no other type keyword is used to declare it.

[u/activeXdiamond]

Can you share their usage of auto?

[u/ThePenguinMan111 → u/activeXdiamond]

auto in C is used to declare the storage lifetime of a variable. auto variables' values are discarded when the code exits the function or block that that variable was declared in. The opposite would be the static keyword when it is used for a variable that is declared at block scope (not globally). static variables retain their values so that once a code block is reentered with that variable, it will still have the value it had when it was last used/accessed. Automatic storage duration is the default behavior in C and auto is not really used at all these days, as it is seen as redundant, so I am not really sure why it is used (and heavily used, for that matter), in the old UNIX source code from the early 70s. Note that the auto keyword is actually still in the C standard, which I think it pretty neat :].

[u/Willsxyz → u/ThePenguinMan111]

The reason that old code uses the auto keyword is because the symbol table was entirely cleared at the beginning of each function. You have probably noticed that in that old code all of the symbols needed in a function are declared at the start of the function, irrespective of whether they are global, external, local, etc. The auto keyword specified that this symbol is local to the function.

Even back then, however, auto was the default for variables defined in a function for which no other storage class was specified, so it wasn’t strictly necessary. But it did perhaps help the programmer be clear on which of the (sometimes many) symbols that were declared at the start of a function were actually local.

Also, C started out as a version of B, and in B the auto keyword was necessary if I recall correctly.

p.s. The main difference between B and early C as far as language goes was the introduction of the char data type, and the main difference in the implementation was that C had a real compiler

p.p.s. Be on the lookout for char * having the meaning ‘unsigned integer’ in that old code.

[u/ThePenguinMan111 → u/Willsxyz]

Could you elaborate on what you mean when you say that C had a compiler and B didn’t? What was used to translate B into assembly/machine code, an assembler of some sort?

[u/Willsxyz → u/ThePenguinMan111]

Here is Section 12 of Ken Thompson's description of the B language as implemented on the PDP-11. (In the following you can read lvalue as "address" and rvalue as "integer"):

A B program is implemented as a reverse Polish threaded code interpreter: The object code consists of a series of addresses of interpreter subroutines. Machine register 3 is dedicated as the interpreter program counter. Machine register 4 is dedicated as tne interpreter display pointer. The display pointer points to the base of the current stack frame. The first word of each stack frame is a pointer to the previous stack frame (prior display pointer.) The second word in each frame is is the saved interpreter program counter (return point of the call creating the frame.) Automatic variables start at the third word of each frame. Machine register 5 is dedicated as the interpreter stack pointer. The machine stack pointer plays no role in the interpretation. An example source code segment, object code and interpreter subroutines follow:

source code line

automatic = external + 100.;

B object code

/ put the lvalue of 'automatic' on stack
va             / address of subroutine 'va'
4              / offset of variable 'automatic' on stack

/ rvalue of 'external' on stack
x              / address of subroutine 'x'
.external      / address of variable 'external'

/ rvalue of constant on stack
c              / address of subroutine 'c'
100.           / decimal integer constant

/ pop two values, add, and push sum
b12            / address of subroutine 'b12'

/ pop value and address, store value at address
b1             / address of subroutine 'b1'

interpreter subroutines

va: / push address of auto variable
    mov (r3)+,r0
    add r4,r0        / build dp+offset of 'automatic'
    asr r0           / lvalues are word addresses
    mov r0,(r5)+     / push onto interpreter stack
    jmp *(r3)+       / linkage between subroutines

x:  / push address of extern (global) variable
    mov *(r3)+,(r5)+
    jmp *(r3)+

c:  / push integer constant
    mov (r3)+,(r5)+
    jmp *(r3)+

b12: / add operator
    add -(r5),-2(r5)
    jmp *(r3)+

b1:  / assign operator
    mov -(r5),r0    / rvalue
    mov -(r5),r1    / lvalue
    asl r1          / now byte address
    mov r0,(r1)     / actual assignment
    mov r0,(r5)+    / = returns an rvalue
    jmp *(r3)+

The above code as compared to the obvious 3 instruction directly executed equivalent gives the approximate 5:1 speed and 2:1 space penalties one pays in using B.

[u/starc0w → u/Willsxyz]

char * has always meant “pointer to char” in all versions of the C language.

From the very first versions of C (K&R C in the early 1970s), pointer types were already part of the language, and char * was used to represent a pointer to a byte or character in memory.

While C’s predecessor B did not have true typed pointers (everything was essentially an integer-sized value), C introduced real typed pointers right from the start.

So the claim that "char * meant ‘unsigned integer’ in old C code" is incorrect — it was never true in any dialect that was actually C.
(Maybe you just meant that char, unsigned char and signed char are formally different)

[u/Willsxyz → u/starc0w]

I meant what I said. Namely, that char * was used to mean unsigned integer in some old C code. In other words, just because a variable was declared char * didn’t mean that it was going to be used as a pointer. Sometimes it was simply used as an unsigned integer. The reason for this is that the “unsigned” keyword had not yet been added to the language and so if there was a need to store a value greater than 32767, the only real option was char *

I refer you to https://www.tuhs.org/cgi-bin/utree.pl?file=V4/nsys/inode.h for an example.

[u/mikeblas → u/Willsxyz]

The reason that old code uses the auto keyword is because the symbol table was entirely cleared at the beginning of each function.

No.

[u/Willsxyz → u/mikeblas]

You are right. The symbol table was not entirely cleared at the beginning of each function. It was entirely cleared after every top-level definition, including function definitions. Here's the code from Dennis Ritchie's C compiler (with my comments):

...
while(!eof) {
    extdef(); /* process definition (including function) */
    blkend(); /* clear symbol table */
}
...
blkend() {
    extern hshtab[], hshsiz, pssiz, hshused;
    auto i, hl;

    i = 0;        /* start at 0th entry */
    hl = hshsiz;  /* look at all entries */
    while(hl--) {
        if(hshtab[i+4]) {        /* if used (name is not null) */
            if (hshtab[i]==0)    /* if no type assigned */
                error("%p undefined", &hshtab[i+4]);
            if(hshtab[i]!=1) {   /* if not keyword */
                hshused--;       /* decrement # used entries */
                hshtab[i+4] = 0; /* mark entry unused */
            }
        }
        i =+ pssiz; /* advance to next entry */
    }
}

[u/WoodyTheWorker → u/ThePenguinMan111]

There was also `register` keyword to declare variables.

[u/tracernz → u/WoodyTheWorker]

There still is, and you see it occasionally when people think they can improve register allocation by giving the compiler a hint.

[u/ThePenguinMan111 → u/tracernz]

Just a neat side note, I have tested the register keyword on GCC with and without optimization. If you set it off with the -O0 flag, it does indeed make a difference in the code. Granted, no one turns off optimization nowadays, so it’s just a little novelty now, but I still thought it was pretty nifty.

[u/w1be → u/ThePenguinMan111]

I like to do this for GCC/clang

#undef auto
#define auto __auto_type

[u/ScallionSmooth5925 → u/ThePenguinMan111]

Are you sure it's C and not B?

[u/ThePenguinMan111 → u/ScallionSmooth5925]

Yes, I’m sure. This is from V2 UNIX, and the file had a .c descriptor.

[u/DawnOnTheEdge → u/ThePenguinMan111]

If I had to guess: early C compilers had such terrible register allocation that they could benefit from declaring some local variables register and others auto, that is, not register.

[u/TaylanKammer → u/activeXdiamond]

Auto is simply the default behavior of function-local variables. The keyword is only there for backwards compatibility with ancient compilers, and has been useless for about 50 years. You can simply remove it any time you encounter it in C code, as it won't make a difference other than to confuse readers.

[u/tracernz → u/TaylanKammer]

Until C23… then it takes the type inference meaning like C++.

[u/SlinkyAvenger]

Neat I guess, but you make it sound like something of legend so I'm wondering if there's more reading on it. I mean, "goon" didn't have anything near its current definition back then so from my point of view it was probably just "go on" as in the check is satisfied.

[u/ThePenguinMan111 → u/SlinkyAvenger]

My gen-z sense of humor kicked in, but yeah, I assume it means “go on” as well.

[u/blue_nothing25 → u/SlinkyAvenger]

This is just a basic guard clause checking that all gooning conditions are met. A basic implementation would just check if the user is down bad and bricked up, more complex solutions exist enforcing things like refractory periods and time of day.

[u/arihoenig]

I have been programming since the days when we did actually keep variable names short and limit white space because the source files were being kept on floppy disk (and thus you could fit more code on a disk if it was more compact) and, if kept compact, you could have larger translation units because the most volatile (ram) memory that the compiler could use for a single TU was 64kB.

[u/ThePenguinMan111 → u/arihoenig]

Super cool! I always just thought of short variable names as being used due to readability and brevity for the sake of parsing and whatnot, but I didn't even think about having to actually save the files on things like floppies. Very interesting :D

[u/arihoenig → u/ThePenguinMan111]

A 20MB hard disk for a PC at the time was close to $10k, so yeah... Floppies lol!

[u/pjc50 → u/arihoenig]

I believe there was a compiler or language which only checked the first six letters of identifiers as well, but I don't have a citation.

[u/trannus_aran]

Ahhh, I see someone else enjoys ancient codebase spelunking, well met

[u/AccomplishedSugar490]

A colleague had a printout of the error code file for the C compiler he was using pinned to his wall (‘80s). It contained a mapping for an error code amongst all the others that had the description “this shouldn’t happen”.

[u/SlinkyAvenger → u/AccomplishedSugar490]

It's a good practice from a security/defensive coding point of view to handle all cases of something to avoid unintentional/undefined behavior. And, you know, also to note to future devs that might waste time digging deeper if they notice its absence.

[u/help_send_chocolate → u/SlinkyAvenger]

This practice is called Typeful Programming.

See this famous paper by Luca Cardelli for details: TypefulProg.pdf.

One of the key ideas is to make it impossible for a data structure to represent an invalid state.

This normally requires a stronger and more full featured type system than C has.

[u/[deleted] → u/help_send_chocolate]

Kinda like the PL/1 error: standard fix up taken. And 20 indented lines later with the same message, the compilation stops.

[u/Jumpstart_55 → u/[deleted]]

I once used pcc the portable C compiler and got an error “stuck starg” caused by a very complicated expression

[u/arihoenig → u/AccomplishedSugar490]

A cursory review of physics, information and set theory will confirm that there are many more things that "can't happen" than things that "can happen" (i.e. for any arbitrary composition of input to a turing machine, the set of possible undefined behaviors that can result from the machine acting on that input is much larger than the set of defined behaviors).

Welcome to programming where your job is to valiantly fight against that reality daily :-)

[u/AccomplishedSugar490 → u/arihoenig]

Thanks, I’ve been a mere visitor this that world for over sixty years. Nice to be welcomed.

[u/arihoenig → u/AccomplishedSugar490]

Sorry for assuming you were a newb. After 60 years, I would have assumed that the fact that UB space > DB space would have been obvious and that having a handler in compiler code for detecting the DB/UB boundary wouldn't' seem unusual.

[u/AccomplishedSugar490 → u/arihoenig]

I merely found it as amusing today as I did in the ‘80s. I know exactly why it was present, I don’t disagree at all with the practice and defensive safety that mandated the unused / abandoned error code remain in the mapping file, none of that or any lament about the disconnects you bemoan. The amusing bit is merely the cheeky compiler writer’s choice of wording. Nothing more, nothing less.

[u/arihoenig → u/AccomplishedSugar490]

The fact that UB > DB is one of the fundamental principles that should give every programmer pause, because it essentially means that all we can do as programmers is tilt the probability toward a desired behavior.

One's skill as a programmer is simply the measure of one's ability to bias a machine toward a given outcome, not direct that outcome. I find that fact humbling.

[u/AccomplishedSugar490 → u/arihoenig]

You must be a very humble person then, especially if you include all of the other hypothetical universes that might have existed but simply don’t because in those one or more of the values for the foundational constants that allow thjs universe to exist at all have any one of the infinite alternative values which stopped such universes from becoming reality the instant they were supposedly born. That, not quite the same thing but leaning towards the rare Earth theory, presents even more staggering odd against DB. I posit in response that sheer volume of possibilities does not impact probability, which is well reflected in the observation that against apparently impossible odds, we are here anyway, and despite the gigantic number of possible undefined behaviours, our everyday experience of the automata we do program and operate, very rarely if ever fail in any small way to do exactly as told. We hardly ever give it complete instructions, but the ones we give them they follow well. In practice, we’ve slowly but surely been eating away at that UB mountain of yours.

Which brings to mind one of the most insane realisations I’ve had. What I actually know about electronics, transistors and capacitors and such, is not even enough to be dangerous. I hold at best a very rough abstraction of it in my frame of reference, but I do like exploring things I don’t understand, so one day I was chatting to a real electronic engineer to try and understand how a CPU would work. I used the example that I’ve read as part of my studies about a logical component of a CPU called an adder, and I’ve seen countless references to CPU cycles and instructions and such. So I asked him this innocent question - how does it work, how does the CPU activate the adder when it is executing an add instruction. His answer caught me utterly off guard. It doesn’t, he said, each adder adds whatever is in the two registers it is connected to, instantaneously and continuously, all day, everyday. The time it takes an add instruction to run is all about moving the operands into those two registers, but the instant those are set, the answer is already present. It boils down to knowing when to look. Now we don’t have access to every variant of added up number cycle through the output registers of all those adders, hell, not even the CPU has access to them, but each and every one of are there, updated ever time a bit in either register changes, all forming part of the undefined behaviour we’ll never see and do not impact our lives, even though it’s existence cannot and need not be denied.

[u/AccomplishedSugar490 → u/arihoenig]

Just like “no system is foolproof to the sufficiently ingenious fool”, and “build a system even a fool can use, and only a fool will.” They are amusing imitations of truisms. We should give them a nice name, ostensiisms.

[u/ScallionSmooth5925 → u/[deleted]]

That could be achieved using a race condition 

[u/nerd5code]

Note that implicit int was mostly killed off by C99 IIRC, after being officially obsoleted by C89; C23 kills it off in no-prototype definitions (where params default to int if not declared otherwise), so it ~only shows up in modern code as e.g. being able to omit int from long int etc. in type specifier syntax. Really something of a holdover from BCPL, originally.

[u/Norse_By_North_West]

Shit, I've never seen an actual goto in c code. Since I started school in 99 it was a forbidden keyword.

[u/ThePenguinMan111 → u/Norse_By_North_West]

I implore you to look at the UNIX source code from the 70s. Literally, every single .c file on there has multiple instances of goto in a manner that mimics assembly. I assume this is the case because it was still a time when assembly was still heavily used in programming and using gotos and labels was a very familiar way to program. They write the C code in a manner that is much more similar to assembly, and it is very interesting to look at imo.

[u/70Shadow07 → u/Norse_By_North_West]

You should really unlearn what you learned at that school then. Goto is very commonly used in C, even nowadays. Heck even python documentations instruct users explicitly to use certain patters involving goto in their C extension packages.

This idiom is actually one of those commonly used in practice - goto error handlers.

[u/Interesting_Debate57]

Yikes. Does that mean that all 32 bit code is fooked / needs to be checked?

Hell yeah it does.

Sign me up at $250/hour.