4.3. En komplet compiler

4.3.1. uC - en mikroskopisk C compiler

I dette afsnit præsenteres en lille C compiler, som man selv kan skrive - eller skrive videre på, nemlig Small-C, som jeg i denne version har kaldt Micro-C, eller uC.

Small-C compileren er legendarisk. I microcomputerens barndom skrev Ron Cain en artikel (eller en artikelserie?) om en lille C compiler, som kunne kompilere sig selv, og som faktisk var/er et nyttigt sub-set af C sproget. Small-C var skrevet til Intel 8080 CPUen, en 8/16 bit CPU og det udbredte styresystem CP/M (Control Program for Microcomputers) fra Digital Research inc.

Den oprindelige source til Small-C har jeg aldrig kunnet finde. Der findes imidlertid mange varianter. En af de bedste er James E. Hendrix's Small-C 2.2, men den er på den anden side også mere kompliceret. En anden version for MS-DOS hed Caprock System PC eller CPC, og det er den, som jeg har arbejdet videre på. Den vigtigste ændring er, at den kører 32 bit under linux og at den i øvrigt benytter samme call-sequence som GNU-C.

Kildetekst og nogle primitive make filer m.v. finder man i et gzippet tar arkiv i eksempel-kataloget, uC09e-3.tgz hedder det pr. 2. juni 2001.

Eksempel på udpakning og installation:

[root@linus /root]# mkdir -p /hjem/src/compiler/ucc
[root@linus /root]# cd /hjem/src/compiler/ucc
[root@linus ucc]# tar xzvf /tmp/uC09e-3.tgz # OBS! Nyeste version kan hedde noget andet
[root@linus ucc]# make
[root@linus ucc]# make install

Hvis man kører make install, vil programmerne lave et symbolsk link fra /usr/local/uC til det sted, hvor man installerer fra. Derfor skal man ikke flytte installations-dir. Man kan let selv lave om på disse ting. Hvis man i forvejen har et directory /usr/local/uC vil man blive bedt om at fjerne det manuelt, så installationen er altså ikke destruktiv.

Leder man på nettet kan man sagtens finde source til andre C compilere, og som bekendt er GNU C "fri software", der distribueres med kildetekst og dokumentation, så den kan man jo også begynde at læse på.

Inden jeg valgte at det skulle være uC, som skulle med som eksempel i denne bog, havde jeg Dennis Ritchies oprindelige "pre-struct" C, LCC, cc68 og cc386 i kikkerten, før end jeg valgte denne. Den er lille og kunne nemt tilpasses til GNU/Linux miljøet. Og -- indrømmet -- jeg kendte den godt i forvejen!

Den nuværende version nummerering indeholder to oplysninger. Linux-porteringen (32 bit versionen) er version 0.9, og den centrale del, parseren, har jeg ladet hedde version 3.01 fordi den jo er baseret på tidligere versioner.

Uddrag fra uCannoncering - filen:

Revision: Version 09 (næsten poleret ...) pr. 6-apr-2001.

Parser-delen er version 3.01

Med tilføjelse af options for extended stackframe og for saving %ebx. (brug -h for at se options).

Assembler output oversættes af GNU "as" og linkes med ld via en gcc kommando.

Den kan bootstrappes på en RedHat 5.2, 6.0 og RedHat 7.0 (benyt --bx option til kompilering af main, se Changelog.dk); jeg formoder, at der også er andre distributioner, som lader sig anvende.

Koden er "acceptabelt ineffektiv", idet den performer ca 1/3 langsommere end gcc genereret kode. Det er egentlig ret forbløffende, idet compileren er meget simpel og har nogle indlysende skavanker, når der skal anvendes array indexering og pointere. Forklaringen er, at de simplere instruktioner, der anvendes, er hurtigere end de komplicerede instruktioner til adressering, som gcc kan generere.

uC er instruktiv i 2 henseender:

1. Dels viser den hvordan man laver en minimal C - compiler med en SUBSET af C, som alligevel er så kompatibelt med (old-style) C at den kan kompileres med en "stor" C compiler

2. Den kan oversætte sig selv.

Hønen og ægget! Hvad nu, hvis man ikke lige har en C compiler ved hånden. Kan man så få denne compiler til at fungere? Ja, det kan man. Den er lille nok til, at den kan hånd-oversættes.

EN SPECIFIKATION AF uC

-----------------------------------------------------
Preprocessor direktiver:
-----------------------------------------------------

#include <stdio.h>  /* leder i /usr/local/uC/include */

#include "fil.h"    /* current dir */

#define YXI 1       /* ikke parameter-macroer */

#ifdef              /* Betinget compilering */

#ifndef
#else
#endif
#asm                /* for hånd - optimering! */
#endasm

-----------------------------------------------------
Datatyper:
----------------------------------------------------
int x;
char w;
int array[n]
char arr[n];
int *ip;
char *cp;

eller

char s[];

extern int y;
&function();

-----------------------------------------------------
Operatorer:
-----------------------------------------------------
Assignment: =  ++ --
Aritmetik:  + - * / % 
Bit:        ~ ^ | &
+shift:     << >>
Logiske:    INGEN (sic)
Dereference *
Address     &

Pointer aritmetik er tilladt (er unsigned)
Struct klares som char[n] med #define offsets

-----------------------------------------------------
Flow
-----------------------------------------------------

if (x) {}
else   {}

while(x) {
break;
continue;
}

return x;

-----------------------------------------------------
Modularitet
-----------------------------------------------------
extern int x;   /* static mangler */

/* extern f(); automatisk hvis ukendt fcn-navn optræder. */

functions returnerer en int. Altid!
function type må ikke specificeres, men den er jo også
redundant, da funktioner altid returnere en int.
prototyper er forbudt! Hu!

separat kompilering og linkning med gnu as og ld.

-----------------------------------------------------
Slut på specifikation af uC
-----------------------------------------------------

Det er meningen her at give en ganske kort beskrivelse af denne compiler. En forsmag kan være den centrale funktion, som parser eksterne objekter:

/*                                              */
/*      Behandling af alt input                 */
/*                                              */
/* På dette niveau er kun statiske erklæringer  */
/*      defines, includes, og function          */
/*      definitions legale                      */
/* Input kaldes fra (a)match                    */

parse()
{
    while (eof == 0) {
        if (amatch("extern", 6)) {
            cextern = 1;
            if (amatch("char", 4)) {
                declglb(cchar); /* declare global */
                ns();
            } else if (amatch("int", 3)) {
                declglb(cint);
                ns();
            } else {
                declglb(cint);
                ns();
            }
            cextern = 0;
        } else if (amatch("char", 4)) {
            declglb(cchar);
            ns();
        } else if (amatch("int", 3)) {  /* cannot handle function type! */
            declglb(cint);
            ns();
        } else if (match("#asm"))
            doasm();
        else if (match("#include"))
            doinclude();
        else if (match("#define"))
            addmac();
        else
            newfunc();
        blanks();               /* preprocess, force eof if pending */
    }
}

Mere i næste version af "Friheden til at programmere i C" ...