2. The C Family

2.1. GCC

GCC is by far the most commonly-used C compiler in the world of Unix; it supports many platforms surprisingly well, and indeed supports an increasing number of languages (classical C, ANSI C, C++, Objective-C, Ada, Pascal, FORTRAN, and others...)

A recent development project related to GCC was called EGCS. Its goal was to fold together a number of independent "hacks" taking place on GCC. Unfortunately, the FSF's needs for GCC were somewhat at odds with the desires of others that have done quite a bit of "hacking" on GCC over the years. As the "GNU System's Compiler," stability was paramount, and the FSF had been reluctant to add various external code to the "GCC2 Tree."

This included such things as:

• FORTRAN support and various language-specific improvements for other languages;

• Instruction scheduling from IBM Haifa ("generic optimizations") that would provide optimization for all platforms at the machine language level;

• Alias analysis and various other optimizations that get applied at the "generic language level," thus applying to all languages and all platforms;

• Improved conformance of the C++ components with the upcoming C++ standards, such as the Standard C++ Library.

EGCS was opened up as a project to try to join many of these changes together into a single "experimental" code stream, to ultimately become the "next GCC." This approach was adequately successful, and EGCS is now GCC.

A set of GCC 3.0 Release Criteria is now pretty ancient and obsolete...

2.2. LCC

lcc, a Retargetable Compiler for ANSI C is notable for the characteristic that it was written using noweb, a Literate Programming tool.

This compiler is considerably smaller and faster than GCC. It does not support as many platforms, and does not provide as sophisticated optimization strategies. On the other hand, it is far more approachable in source code form, and is probably a lot easier to understand.

• A Retargetable C Compiler : Design and Implementation (LCC)

2.3. ANDF/TenDRA

This project was originally sponsored by the Open Software Foundation, now Open Group, and sought to create tools to manipulate software in ANDF - Architecture Neutral Distribution Format.

The intent was to be able to compile software in various languages including C, C++, and Ada95, producing "object code" in the ANDF format, which would then be turned into machine-specific executables on the target host.

Vendors could produce programs in ANDF form, and they should "just run" on any of the target platforms. A local installer application would transform ANDF inputs to produce target-specific forms.

The main available result of the efforts is the TenDRA C/C++ Compiler set using ANDF. Compilers for Ada95, Dylan, and possibly other languages, were created, but are not publicly available.

The ANDF approach is not unlike the way GCC uses RTL , except that with GCC, RTL is used as an internal step in the compilation process, and is not intended to be useful as a "code distribution" form. Notably, the GCC RTL form winds up being quite platform-specific, whereas ANDF is a platform-independent distribution form.

Apparently, "The project ended somewhat acrimoniously in April 1998;" for all intents and purposes, TenDRA development "died." In 2002, some interest has re-emerged.

Supported platforms have included:

• AIX/PPC

• HP-UX/PA-RISC

• Irix/MIPS

• Linux/IA-32

• OSF1/Alpha

• SCO/Intel

• Solaris/SPARC, Solaris/IA-32, SunOS/68K

• Ultrix/MIPS

• Unixware/IA-32

• TenDRA.org

• TenDRA Home Page

• Debian packages may be found here.

• There is also a BSD Ports version here.

It seems unfortunate to me that this fell so badly by the wayside; the availability of a compiler suite with a fairly substantially different model from GCC would seem likely to offer three significant merits:

• It would allow more ambitious experimentation to take place without substantially increasing the risks associated with failure;

• The fact of having a different architecture implies that different improvements might take place; improvements that might be inconvenient to implement with GCC might be easier to add to a different compiler;

• Having substantially different compilers in use encourages conformance with actual standards, and discourages people from writing code that merely, conveniently, happens to work with GCC.

  For instance, the Linux kernel is exceedingly dependent on GCC, indeed, it tends only to compile successfully when GCC versions are selected fairly carefully. In a sense, Linux thus isn't "written in C;" it is written in the "GCC dialect of C."

  The problem with that is that if GCC is modified to improve optimization of code, this occasionally breaks code that depends on GCC generating code in a particular way. In effect, this discourages improvements to GCC; if Linux was also compilable with TenDRA, that issue would be somewhat relieved, which, with LLVM/CLANG, has actually led to some of the BSD OSes switching away from GCC, and there have been some similar efforts with Linux.

2.4. Other C Implementations

• The LLVM Compiler Infrastructure Project

• The OpenWatCom Project

  Sybase has decided to release the Watcom C and FORTRAN compilers as free software.

  Thus far, the main targets are Win32, OS/2, and MS-DOS; we'll see if it becomes of wider interest...

• pcc - pcc portable c compiler

  This hearkens from fairly early days of C (indeed, to the 1970s), but was not maintained much for a long, long time. Efforts (associated somewhat with ) to make it useful again began in 2007.

  It has been updated to C99, and has become sufficiently operable that it has been used to generate kernels on x86.

• Amsterdam Compiler Kit (ACK)

  The Amsterdam Compiler Kit is an integrated collection of programs designed to simplify the task of producing portable (cross) compilers and interpreters. For each language to be compiled, a program (called a front end) must be written to translate the source program into a common intermediate code. This intermediate code can be optimized and then either directly interpreted or translated to the assembly language of the desired target machine.

  The current version contains front-ends for Modula-2, C, ANSI C, Fortran, Pascal, Basic, and occam, and back-ends for a.o. DEC PDP-11, DEC VAX, Motorola 68000, Motorola M68020, SPARC, Intel 8080, Intel 8086, Intel 80386, Zilog Z80, Zilog Z8000, NS 16032. Also included are a parser generator called LLgen, a code-generator-generator (the code-generators are table-driven), a peephole optimizer on the intermediate code, a global optimizer on the intermediate code, table-driven machine-dependent peephole optimizers, and many other utilities.

  This compiler kit was notably used to implement Minix. Richard Stallman asked if it could be made available to the GNU Project as their C compiler; when Tanembaum declined, work proceeded on GCC.

• The Development of the C Language

• Mix Software has been selling some seriously inexpensive C tools for CP/M and MS-DOS for many moons. $50 buys you compiler, a database library (ISAM), a character-based GUI library, as well as a small POSIX-like realtime multitasking kernel that runs atop MS-DOS.

  It's not fancy, but it's tiny, running on hardware that couldn't support GCC...

• CIL - Infrastructure for C Program Analysis and Transformation

  CIL compiles valid C programs into a small set of core constructs. It is apparently able to process the Linux kernel , complete with GCC extensions.

  The point of it is to transform C code into a sort of "lowest-common-denominator" form that would be amenable to further processing.

  Implemented using OCAML .

• BD Software

  BDS C, the original CP/M C

• There is the theory that C is a "compiled" language; this isn't exclusively true, as various C interpreters exist...

  • The CINT C/C++ Interpreter

  • Ch -- an embeddable C/C++ interpreter, compiler for numerical computing

  • UPS DEBUGGER

    A debugger that includes a C interpreter

• Obfuscated Tiny C Compiler

  My goal was to write the smallest C compiler which is able to compile itself. I choose a subset of C which was general enough to write a small C compiler. Then I extended the C subset until I reached the maximum size authorized by the contest: 2048 bytes of C source excluding the ';', '{', '}' and space characters.

• Tiny C Compiler

  An optimizing C compiler that is IA-32-specific, but which is tiny in size, and runs quick on IA-32 Linux systems.

2.5. Other General C Links and Tools

• C Programming Language (2nd Edition) - K and R

• C: A Reference Manual (5th Edition) - Harbison and Steele

• C standardisation:ISO

• The Development of the C Language - Dennis Ritchie

• LCLint

  LCLint is a program that analyzes C source files and reports non-portable or error-prone situations. It can be configured at a very fine-grained level so you can select the types of errors/warnings to generate.

  If you annotate your source code with comments indicating information about the flow of control/data, it can perform additional checks to find dangerous data accesses and incorrect program logic that cannot be found by a traditional lint.

• splint

  Splint is a tool for statically checking C programs for security vulnerabilities and coding mistakes. With minimal effort, Splint can be used as a better lint. If additional effort is invested adding annotations to programs, Splint can perform stronger checking than can be done by any standard lint.

• C9X: The New C

• comp.lang.c FAQ

• The Top 10 Ways to get screwed by the C programming language

• CCMALLOC - A memory profiler

  An easy to use memory profiling and malloc debugging library for C and C++ programs. It can finds leaks, multiple deallocations, and memory corruptions.

• Boehm Memory Manager, providing a conservative garbage-collector to automate the allocation and deallocation of memory.

• GNU Indent

• The International Obfuscated C Code Contest

• CCIDE - Decision Table Code Generator

  Reads a file containing an embedded decision table along with C code to support this, and generates C code to implement the table.

• GCC XML Introspector Project

  GCC AST Tree_Node Project with PostgreSQL Interface

• Flawfinder

  A program that examines source code and reports possible security weaknesses ("flaws") sorted by risk level.

• Distcc - a fast, free distributed C/C++ compiler

• Sparse - a Semantic Parser for C

• Xoc, an Extension-Oriented Compiler

2.6. C++

• The C++ Programming Language (Special 3rd Edition)

• GCC-XML the XML output extension to GCC

• STLport: An Interview with A. Stepanov

  The author of the STL template programming system for C++ indicates that STL is not object oriented, and thinks that "object orientedness is almost as much of a hoax as Artificial Intelligence."

• How Not To Program in C++

  A gallery of broken C++ programs, with hints and answers.

• The Invention of C++ - Nice bit of net lore

2.7. Objective C

Objective C was designed by Brad Cox, and adds object-oriented "extensions" to C. It is considered to be simpler to learn than C++. Objective C is the language used to implement NeXTStep, and is the "language of choice" for use with OpenStep and GNUStep.

GCC has a "front end" for Objective C that was developed by NeXT.

Another description is that Objective-C is a cross between Smalltalk and C. As a true superset of C it is ideal for putting object wrappers on existing C libraries.

• Portable Object Compiler at SourceForge

  The Portable Object Compiler consists of a set of Objective C class libraries and a precompiler (translator) that generates plain C code.

• Blocks in POC

• The Eero Programming Language

  A syntactically streamlined dialect of Objective-C using Clang/LLVM. It looks quite a lot like Python, removing most semicolons, using whitespace to indicate control structures.

• Objective C Blocks

• Learning Cocoa with Objective-C, 2nd Edition

• Objective-C; Object-Oriented Programming Techniques

• An Introduction to Object-Oriented Programming - A fairly recent guide to Objective C

• Object-Oriented Programming and the Objective-C Language

• Portable Object Compiler - Objective C

• Black Shoals - Stock Market Planetarium...

  Implemented in Objective C using MacOS-X

• Optimization of Objective C

  This document describes a number of optimizations that have proved useful to substantially improve the performance of Mac OS-X programs. In theory, the techniques might also be meaningful for GNUStep , although some comparisons have been done that indicate that GNUStep has a different set of bottlenecks so that the techniques have little effect there.

2.8. BCPL

Before C, there was BCPL.

• BCPL

  BCPL is a simple typeless language that was designed in 1966 by Martin Richards and implemented for the first time at MIT in the Spring of 1967.

• Dennis Ritchie's BCPL Page

  C was based on the B language, which was based on BCPL.

• 8bc - B Compiler for PDP-8

• Clive Feather's BCPL Page

• MCPL

  MCPL is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching somewhat related to that used in ML and Prolog, and some other features come from C.

• T3X Project

  T3X is intended as a "minimal" procedural language. It looks a lot like a cross between Algol and C, and consciously inherits a great deal from from BCPL , notably a quasi-typeless variable system. The design goals are thus:

  • Simple syntax and semantics

  • High portability

  • Simple self-hosting implementation

  • Suitability to both interpretation and generating native code

2.9. Other C/C++/ObjectiveC stuff

• Kernighan, Brian

  One of the creators of C and Unix...

• Incompatibilities Between ISO C and ISO C++

• Moylan: The case against C.

• The Cilk Project

  A C-like language designed for multithreading

• Simple Pipe example

  FILE* sendmail; sendmail=popen("/usr/lib/sendmail -t","w"); /* should really check for error here */ fprintf(sendmail,"To: %s\nSubject: %s\n\n",to,subject); fprintf(sendmail,.....); /* message body */ pclose(sendmail); /* should really check for error here */

  Or alternatively:

  FILE* sendmailFd; sendmailFd = connect_port(hostname,25); write(sendmailFd,"HELO", 4); ...stuff...

• Cilk Papers

  Cilk adds some parallelism keywords to ANSI C

2.10. The Go Language

• Go Language

• Go By Example

• GitHub of Go By Example

2.11. Rust

The Rust language is a would-be successor to C++ as a "systems implementation language."

It has a number of interesting aspects:

• It has a clear idea of mutability, favouring immutable bindings

• It has a notion of ownership so that data can be owned by just one variable at a time, and is dropped once obsolete. This allows safer handling of concurrency.

• Traits are similar to interfaces in other languages, indicating functionality that may be shared with other data types.

• It has many of the common modern-ish data structures and manipulators such as strings, arrays, associative arrays

• It has very good integration with C by having a Foreign Function Interface that understands C very well.

  As a consequence, it is possible to take a complex program written in C and incrementally shift the program into native Rust, perhaps as little as a function at a time.

  This is being used, at Mozilla, to transform Firefox into Rust, thereby getting the various safety and concurrency improvements Rust offers, a module at a time.

  A group is working on rewriting the GNU Emacs backend (that implements Emacs Lisp) in Rust, replacing C with Rust, a few functions at a time.