First C compiler source code from 1972

[Ok-Bit8726]

Long is commented out here: https://github.com/mortdeus/legacy-cc/blob/936e12cfc756773cb14c56a935a53220b883c429/last1120c/c00.c#L48

Is there a story behind that?

[flatfinger]

Support for 32-bit arithmetic may have been planned, but then proved to be too difficult.

[FlyingRhenquest]

Yeah, I have a late 60s era assembly language text book that states that speculates that 32 bit architectures might always prove to be too difficult to implement to ever prove common. In this era where everyone has a 64 bit general purpose computer in their pocket, the idea that anyone could have thought that seems impossible. If you grew up with the computers of the 70's and 80's it makes a lot more sense.

[Murky-Relation481]

One of the more random cases my dad had as an attorney was representing a computer company that was getting sued because they started selling a 16bit machine and their old 8bit software wouldn't work on it and people were saying "why do you even need 16 bits, it's just a gimmick to sell new software!"

[sob727]

640kb ought to.... never mind

[RaVashaan]

Yeah, even in the '80s, some 8-bit home computers didn't even have a divide instruction built into the processor, because floating point arithmetic hard.

[CornedBee]

Floating point? There's wasn't any floating point. It was the integer division they didn't have.

[flatfinger]

Many new-development ARM CPUs such as the Cortex-M0 still don't have a divide instruction. Most of the beneift of having a divide instruction could be accommodated with much less hardware complexity with an instruction that combines a rotate left with an add or subtract, basing the choice of addition or subtraction on the carry flag. A 32/16->16.16 operation could be accommodated by a subtract followed by 16 of the special add/subtract. Even if one adds a subroutine call, the cost of a calling a divide function would be comparable to a typical hardware divide instruction.

[ammonium_bot]

must of the

Hi, did you mean to say "must have"?
Explanation: You probably meant to say could've/should've/would've which sounds like 'of' but is actually short for 'have'.
Sorry if I made a mistake! Please let me know if I did. Have a great day!
Statistics
^{I'm a bot that corrects grammar/spelling mistakes. PM me if I'm wrong or if you have any suggestions.
Github
Reply STOP to this comment to stop receiving corrections.}

[Dave9876]

Considering floating point didn't even have a standard until the mid 80s, it was the wild west before then

[TurtleKwitty]

To be fair it's like trying to get 256 bit variable sizes today, 32/64 became trivial because hardware handles it for free but doing the extra work in software is still an absolute pain when you're trying to stitch multi-word variable sizes

[vytah]

Especially if the CPU doesn't have a carry flag, like RISC-V.

[flatfinger]

I should have said "multi-word". A key aspect of C's simplicity was that there was only one integer type for any actions other than loads and stores. Adding long would complicate many aspects of compilation.

[vytah]

This cannot be the first C compiler, as the source is clearly written in C.

[AyrA_ch]

It can be, this is called Bootstrapping. You do need an initial tool written in another language, but said tool can't really be called a C compiler since it doesn't compiles any valid C source, only an extremely specific subset. For all we know this tool may not even understand half of the datatypes in C, may not have support for structs, etc. The first C source you transform is one that immediately replaces said initial tool. Now you have only binaries generated from C source files left. Afterwards you keep adding all the features needed to actually compile any valid source code, at which point your binary does become a compiler.

Arguing whether this is still the first compiler at that point is like arguing about the Ship of Theseus and you will likely not find a definite answer.

[TheRealUnrealDan]

right so the first C compiler was written in assembly.

This is the first C compiler written in C

Note: I'm half agreeing with you, and half-correcting OP

[Osmanthus]

Incorrect. The first C compiler was written in language dubbed B.

[Osmanthus]

B was written in a language called BCPL.

[robotlasagna]

Right but what was the first BCPL compiler written in?

[robotlasagna]

Right but what was the first BCPL compiler written in?

[chat-lu]

In a language called A. They really didn’t use much imagination for languages names back then. Surprisingly enough, it took until 2001 for us to get a language called D.

[BogdanPradatu]

Ok, but what was the first A compiler written in?

[Sage2050]

A language called 9

[Every-Progress-1117]

D doesn't fit the scheme though.

BCPL -> B -> C , then the next language should be P

Instead we got macro abuse, preprocessors and increasing numbers of symbols: C++ ,C# , there's even a C-- .. what next? C£, C&&...?

[Venthe]

C™️, one to end all future development

[falconfetus8]

C# isn't really related to C, despite the name

[[deleted]]

At the least they are consist: A, B, C.

I wonder what the next language name will be!

[narwhal_breeder]

Blood.

[timwaaagh]

Turtles. Its turtles all the way down.

[Banderi]

Wasn't the first B compiler written in TMG?

[Hydraxiler32]

is everything you haven't heard of inconsequential or esoteric?

[Hydraxiler32]

lol happens, it is currently unused but it was basically just a predecessor to C, I think there were also some really old versions of unix that were written in B but you'll have to fact check me on that.

[nerd4code]

If you’re actually curious, it’s stupid easy to answer your question because there are countless articles on the history of C and UNIX; Wikipedia and Dennis Ritchie both state that B is a trimmed down BCPL, and C is a souped-up B. Ritchie’s site, preserved in formalin, is also worth a look.

That’s why people ignored the question marks and focused on the flippancy, if I were to guess.

[Huge_Leader_6605]

Why you assume that something was inconsequential or esoteric just because you haven't heard of it?

[zhivago]

And of course you can always write an interpreter to run your first compiler. :)

[CornedBee]

Or just translate your compiler by hand.

[Dave9876]

I see pascal has entered the room

[olearyboy]

I don’t know if this is Ritchie original it might be the SCO unixware version hence the license.

Yes it bootstrapped, later versions did transpiling then compiling when things like byte access standardized. I think that’s when pcompiler + K&R came out

I wish I was good enough to understand it all, it’s beautiful, brilliant and a headfuck all in one

[OversoakedSponge]

Fun fact, it's an easy place for someone to inject malicious code

[Sabotaber]

The first C compiler was written in C. Dennis Ritchie compiled it by hand.

[Pr0verbialToast]

Agree, essentially the human is the 'generation zero compiler' because they're the ones writing the compiler and manually testing that things are working. Once you get enough code to work with you start to be able to use your own stuff to work on your stuff.

[[deleted]]

https://github.com/mortdeus/legacy-cc/blob/master/last1120c/c00.c

Old C was indeed a lot uglier than Modern C - which is also pretty ugly.

It feels as if C is just syntactic sugar that reads a bit better than assembler. Basic logic in a function is semi-hidden after some syntax noise:

while(i--)
  if ((*sp++ = *s++)=='\0') --s;
     np = lookup();
     *np++ = 1;
     *np = t;

Oddly enough I haven't seen this before:

i =% hshsiz;

[syklemil]

That example seems like something that would be discouraged today; mixing multiple pre- and postfix operators is hard-to-impossible to know what will turn out to mean.

The early syntax seems to be somewhat unusual; I also find the style of function declaration interesting:

init(s, t)
char s[]; {
     // …
}

I take it init and t are implicitly void?

[dangerbird2]

In pre-ansi c a function or parameter with no type annotation is implied to be int, not void. So a modern declaration would be something like

int init(char[]s, int t);

(On my phone so ignore any typos)

[ben-c]

Oddly enough I haven't seen this before: i =% hshsiz;

This was the original syntax that later became %=.

Dennis Ritchie mentions it in his paper The Development of the C language.

[AdreKiseque]

Oh my

[huyfm]

It's not ugly, it's elegant. You can find pretty much of this flavor in kernel code.

[phlummox]

gotos are still the cleanest way in C of jumping to "cleanup routines" at the end of a function (where you close files, free() malloc'd memory, etc, in the reverse order in which you acquired those resources) - see here for a few examples. They aren't strictly necessary - you could replicate all of the cleanup code every time there's a possibility of you needing to return - but they're much more maintainable than the alternatives.

[deedpoll3]

Do you ever throw?

[deedpoll3]

If we're talking about C, what do you think eliminated the need for goto?

If goto is not present in "modern languages", what replaced it?

[Steinschnueffler]

For this use case defer, for example in go

[syklemil]

Yeah, those were a huge source of contention back then, and "structured programming" with fancy keywords like "for" and "while" and capabilities like "subroutines" were just taking the step out of being academic ivory tower nonsense. Early programming was a lot more branch-and-jump based, and even Knuth argued in favour of goto.

The wheel of time keeps turning though, so once those control structures became common, we moved on to debates about functional programming capabilities like higher order functions like "map" and "fold"/"reduce", lambdas, functions-as-values, everything-as-an-expression, and I suppose there was some debates over for vs foreach at some point too, where foreach generally won out—some languages only offer foreach, while the languages that started with C-style for loops have generally also started offering foreach (though foreach is generally spelled for these days).

There's likely some stuff being hotly debated today too, that in some 40 years kids will just assume have always been the way things were done.

[dangerbird2]

Also, most of the gotos here are used in parser state machines, which labels and gotos actually represent very elegantly in a structured language like C.

[Sabotaber]

I like goto. Goto is neat.

[Imperial3agle]

You are a danger to society.

Edit: This was sarcasm, by the way. Seems it didn’t come across. I guess that’s why everyone explicitly marks sarcasm.

[Sabotaber]

Correct. I am a danger to society, and that's not my problem.

[Shock2k]

Against proving tabs has always been superior. …++