/c/programming / § C / thread
← C
Thread
▲6▼

Been studying the original C compiler from 1972 by Ritchie.

by u/tolwiz[MOD][ADMIN]26 days ago7 comments
Researching early Unix and low-level systems, and I ended up spending a good amount of time with this: the actual source of the first C compiler, written by Dennis Ritchie in 1972. Everything we write today traces back to this. Worth reading if you haven't... source: https://github.com/jserv/unix-v1/tree/master/src/c
// 7 comments
Log in to join the discussion.
▲4▼
u/QuietReader42 26 days ago
I've seen this before, and Unix source code from Lyon's book. It is interesting the environments back then versus today. For example the extremely short file names, because you couldn't have file names long enough to be descriptive on the smaller systems, and even the short variables names. Sometimes it saves disk space, but occasionally it's much easier to type when you're on a clunky teletype machine. Also, the primitive early syntax of C is unusual. I didn't see any structs, but you see them in Unix source. The struct there is not like later C but is essentially just declaring name spaces that are shared in common (like common sections in Fortran). Or imagine that all structs exist within an implicit unnamed union, with each field being just a notation for an offset.
▲1▼
u/NightOwlDev 26 days ago
the book, went through it too. The constraint driven design is what gets me. And that point about structs is interesting tbh.the way namespaces worked in early C really does feel closer to Fortran COMMON blocks.
▲1▼
u/CosmicExplorer 26 days ago
If the 1972 compiler is like the 1974 one, structure members behave as though all structure types are in a union with each other. The compiler would need to remember the total size of items for each structure tag, but if the compiler encountered struct foo x; it would need to associate x with the current value of the "next object location", and bump the "next object location" by the size of a struct foo, but once the compiler had reserved space for x it wouldn't need to care about what kind of structure x identified.
▲2▼
u/QuietReader42 26 days ago
As a language at that time, this C is far closer to basic assembler language than later C versions. Thus everything is simple, don't bother with types, only basic operations with simple translations to assembler.
▲0▼
u/CosmicExplorer 26 days ago
I'm pretty certain that by the time the evolving derivative of B was called C, it recognized "pointer to character" and "pointer to integer" as distinct types, along with "pointer to X" (in which case the symbol identified to a container holding the address of something" versus "array of X" (where a symbol itself would identify the starting address of the array).
▲0▼
u/CuriousExplorer99 26 days ago
I started with the ancestor of B, which was totally typeless.
▲0▼
u/CuriousExplorer99 26 days ago
[deleted]