Gamma Reference Implementation

The very beginning

Just like C, Gamma is designed to permit functional implementations with relatively good performance. The following is presented on the specification page, but I'll summarize it here:

Simpler syntax: the grammar and syntax were deliberately chosen to avoid the problematic patterns that require the lexer hack in C;
Minimal runtime support: apart from true array support and nested subprograms, Gamma does not stray far from C in this principle;
Simple standard library: apart from unicode support, abstract data types and a different organization, Gamma follows the words of Bjarne Stroustroup, providing "that which every implementer must support so that every programmer can rely on it";
Cleaned up linkage: unlike the C family, Gamma uses a linkage procedure designed deliberately with interprocedural optimization in mind.

This results in:

Three compilation programs:
- g2i, which works as a function and translates a source or header unit to an intermediate format, only performing syntactic and semantic checks;
- lg, which works as an archiver and edits intermediate files by adding, replacing or removing functions, and on some platforms linking those files to shared libraries; and
- i2m, which works like g2i and transforms an intermediate format file into a target machine language (LLVM IR by default for now);
Two main libraries:
- libg, which implements the functions of the Gamma standard declarations; and
- grt, which implements the runtime behavior of the Gamma language;
Three execution programs:
- ge, which just executes a program in a similar way to ld.so;
- gp, which profiles a program; and
- gt, which traces a program.

Example usages:

g2i:
- Translate a header unit while preserving comments:
```
g2i h --comments < hdr.gh > hdr.t
```
- Translate a source unit, using declarations in math/blas.t:
```
g2i s math/blas.t < src.gs > src.p
```
lg:
- Link all symbols in the intermediate file mylib with a BLAS implementation:
```
lg l mylib.p /usr/lib/libblas.so
```
- Unlink all symbols in the intermediate file mylib from a BLAS implementation:
```
lg u mylib.p /usr/lib/libblas.so
```
- Combine symbols from intermediate files foo, bar and baz into qux:
```
lg a qux.p -f foo.p -f bar.p -f baz.p
```
- Rename a symbol max: nmax(a: nmax, b: nmax) to _max: nmax(a: nmax, b: nmax):
```
lg e qux.p -s 'max: nmax(a: nmax, b: nmax)=_max: nmax(a: nmax, b: nmax)' 
```
- Replace the definition of symbol max: nmax(a: nmax, b: nmax) with the definition in foo:
```
lg e qux.p -d 'max: nmax(a: nmax, b: nmax)' -f foo.p 
```
- Remove a symbol max: nmax(a: nmax, b: nmax):
```
lg d qux.p 'max: nmax(a: nmax, b: nmax)'
```
i2m:
- Translate an intermediate unit into an ELF executable (with a Linux-compatible entry point, e.g. _start: n4()):
```
i2m ELF:x < prog.p > prog
```
- Translate an intermediate file into an ELF shared library:
```
i2m ELF:s < foo.p > libfoo.so 
```
- Translate an intermediate file into an ELF shared library, preferentially inlining calls to the function max: nmax(a: nmax, b: nmax):
```
i2m ELF:s --inline='max: nmax(a: nmax, b: nmax)' < foo.p > libfoo.so 
```
- Translate an intermediate file into a Windows executable with entry point qux: n4():
```
i2m PE:exe -e 'qux: n4()' < foo.p > foo.dll 
```
- Translate an intermediate file into a DLL:
```
i2m PE:dll < foo.p > foo.dll 
```