Home  |  Plan  |  Index  |  Suchen

Convert to GutenPalm or to PalmDoc von Lorne Bailey <sherm_pbody(at)yahoo.com> Über den Autor: Lorne lebt in Chicago und arbeitet als Computer-Berater, spezialisiert auf den Umgang mit Oracle-Datenbanken. Seit seinem Umstieg auf ausschließliche *nix-Programmierung, hat Lorne die DLL-Hölle komplett vermieden. Derzeit arbeitet er an seinem Master-Titel in Informatik. Übersetzt ins Deutsche von: Rene Süss <rene.suess(at)datentechnik.com> Inhalt: GCC ist klasse Zum Anfang... Vor-Kompilieren Kompilieren Assemblieren Linken Zwei weitere wichtige Optionen Debuggen Zusammenfassung Links Talkback für diesen Artikel

GCC - der Ursprung von allem

Zusammenfassung:

Dieser Artikel geht davon aus, dass Du die Grundlagen der Programmiersprache C beherrscht, und wird Dir zeigen, wie Du den gcc als Compiler verwendest. Wir werden dafür sorgen, dass Du den Compiler für einfachen C-Code direkt von der Kommandozeile aufrufen kannst. Danach werden wir einen Blick darauf werfen, was gerade passiert, und wie Du die Kompilierung Deiner Programme kontrollieren kannst. Außerdem werden wir einen Blick auf die Verwendung eines Debuggers werfen.

GCC ist klasse

Kannst Du Dir vorstellen, Freie Software mit einem kommerziellen, "closed Source" Compiler zu kompilieren? Woher weist Du, was in deinem ausführbarem Programm passiert? Es könnte eine Art Hintertür oder ein Trojaner eingebaut werden. Ken Thompson, schrieb für einen der größten Hacks aller Zeiten, einen Compiler, der eine Hintertür in das 'login' programm einbaute und den Trojaner verewigte, als der Compiler merkte, dass er sich selbst kompilierte. Lies seine Beschreibung dieses Klassikers hier. Glücklicherweise haben wir gcc. Immer wenn Du ein configure; make; make install ausführst, macht gcc eine Menge Arbeit im Hintergrund. Wie lassen wir gcc für uns arbeiten? Wir werden damit anfangen, ein Kartenspiel zu programmieren, aber wir werden nur soviel schreiben, um die Funktionalität des Compilers zu demonstrieren. Da wir von Grund auf starten, haben wir gute Voraussetzungen dazu, den Kompilierungsprozess zu verstehen und was in welcher Reihenfolge passiert, um ein ausführbares Programm zu erzeugen. Wir werden einen Überblick bekommen, wie ein C-Programm kompiliert wird, und die Optionen, um dem gcc zu sagen, was wir wollen. Die Schritte (und die Werkzeuge, die das machen ) sind Vor-kompilieren (gcc -E), Kompilieren (gcc), Assemblieren (as), und Linken (ld).

Zum Anfang...

Zuerst sollten wir wissen wie man den Compiler aufruft. Es ist wirklich einfach. Wir werden mit dem klassischen ersten C-Programm anfangen. (Fortgeschrittene müssen mir vergeben).

#include <stdio.h>

int main()

{
  printf("Hello World!\n");
}

Speichere diese Datei als game.c. Du kannst sie in der Kommandozeile übersetzen mit:

gcc game.c

a.out
Hello World

gcc -o game game.c

game
Hello World

An diesem Punkt sind wir immer moch ein gutes Stück davon entfernt, ein sinnvolles Programm zu haben. Wenn Du jetzt denkst, dass sei schlecht, solltest Du berücksichtigen, dass wir ein Programm haben, dass sich kompilieren lässt und läuft. Wenn wir jetzt Stück für Stück Funktionalität in das Programm bringen, dann nur um sicher zu gehen, dass es ausführbar bleibt. Es scheint so zu sein, dass jeder angehende Programmierer zuerst 1000 Zeilen Sourcecode schreiben, und dann alles auf einmal korrigieren will. Niemand, und ich meine Niemand kann das. Du schreibst ein kleines Programm, das funktioniert, du änderst es und lässt es wieder laufen. Das schränkt die Anzahl der Fehler, die Du auf einmal korrigieren mußt, ein. Und, Du weißt genau, was Du gerade getan hast, damit Du es korrigieren kannst. Dies hält Dich davon ab, etwas zu erzeugen, von dem Du denkst, dass es arbeiten sollte, und auch kompiliert werden kann, aber niemals laufen wird. Erinnere Dich, nur weil es kompiliert wird, ist es nicht richtig.

Unser nächster Schritt ist, ein Header-File für unser Spiel zu erzeugen. Ein Header-File sammelt Datentypen und Funktionsdeklarationen an einem Ort. Dies stellt sicher, dass die Definitionen der Datenstrukturen übereinstimmen, so dass jeder Teil unseres Programms genau das gleiche sieht.

#ifndef DECK_H
#define DECK_H

#define DECKSIZE 52

typedef struct deck_t
{
  int card[DECKSIZE];
  /* number of cards used */
  int dealt;
}deck_t;

#endif /* DECK_H */

Speichere diese Datei als deck.h. Nur .c Dateien werden kompiliert, also müssen wir unsere Datei game.c ändern. In Zeile 2 der Datei game.c, schreib #include "deck.h". In Zeile 5 schreib deck_t deck; Um sicher zu gehen, dass wir nichts zerstört haben, kompilieren wir es nochmal.

gcc -o game game.c

Keine Fehler, kein Problem. Wenn es nicht kompilierbar ist, arbeite daran, bis es funktioniert.

Vor-Kompilieren

Wie weiß der Compiler, was ein deck_t Typ ist? Während der Vor-kompilierung, wird die Datei "deck.h" in die Datei "game.c" kopiert. Die Vor-kompilierer Anweisungen sind durch ein "#" gekennzeichnet. Du kannst den Precompiler (Die Vor-kompilierer) über den gcc mit der Option -E aufrufen.

gcc -E -o game_precompile.txt game.c
wc -l game_precompile.txt
  3199 game_precompile.txt

1. Kopieren der "#include" Dateien in das zu kompilierende Source-File.
2. Ersetzen der "#define" Texte mit den aktuellen Werten.
3. Ersetzen der Macros in der Zeile wann immer Sie aufgerufen werden.

Kompilieren

Als Zwischenschritt übersetzt gcc deinen Code in Assembler-Code. Um das zu tun, muss er ausrechnen, was Du tun wolltest, indem es deinen Code übersetzt. Wenn Du einen Syntax-Error machst, wird er es Dir das mitteilen und der Kompilierungsvorgang wird abgebrochen. Manche Leute glauben, dass dies der einzige Schritt im Kompilierungsvorgang ist, aber es gibt noch mehr für gcc zu tun.

Assemblieren

as übersetzt den Assembler Code in Object-Code. Object-Code kann nicht am Prozessor verarbeitet werden, aber er ist schön geschlossen. Die Compiler Option -c verwandelt eine .c Datei in ein Object-File mit einer .o Endung. Wenn wir

gcc -c game.c

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "deck.h"

static time_t seed = 0;

void shuffle(deck_t *pdeck)
{
  /* Keeps track of what numbers have been used */
  int drawn[DECKSIZE] = {0};
  int i;

  /* One time initialization of rand */
  if(0 == seed)
  {
    seed = time(NULL);
    srand(seed);
  }
  for(i = 0; i < DECKSIZE; i++)
  {
    int value = -1;
    do
    {
      value = rand() % DECKSIZE;
    }
    while(drawn[value] != 0);

    /* mark value as used */
    drawn[value] = 1;

    /* debug statement */
    printf("%i\n", value);
    pdeck->card[i] = value;
  }
  pdeck->dealt = 0;
  return;
}

Speichere diese Datei als shuffle.c. Wir haben eine Debug-Anweisung in den Code eingefügt, damit gibt es uns, wenn das Programm läuft, die Kartenwerte aus, die es generiert. Dies verändert zwar nicht die Funktionalität unseres Programms, aber es ist entscheidend, da wir wissen, was jetzt geschieht. Da wir gerade erst mit dem Spiel anfangen, haben wir keine andere Möglichkeit, um zu testen, ob unser Programm das tut, was wir wollen. Mit der printf Anweisung können wir exakt sehen, was gerade passiert, also können wir jetzt mit der nächsten Phase beginnen, wo wir wissen, dass unser Blatt gut gemischt ist. Nachdem wir uns daran erfreut haben, dass es richtig arbeitet, können wir diese Zeile wieder aus dem Code entfernen. Die Art, ein Programm zu debuggen, wirkt zwar etwa ordinär, aber es es ist die unkomplizierteste Art. Wir werden aufregendere debugger später kennenlernen.

1. Wir schreiben eine Variable mit ihrer Adresse, welche man mit dem '&' (Addresse von) Operator erhält. Diese übergibt die Maschinenadresse der Variablen an die Funktion, also kann die Funktion selbst die Variable ändern. Es ist zwar möglich mit globalen Variablen zu arbeiten, aber diese sollten nur selten verwendet werden. Zeiger sind ein wichtiger Teil von C und sollten gut verstanden werden.
2. Wir verwenden einen Funktionsaufruf von einer neuen .c Datei. Das Betriebssystem schaut immer nach einer Funktion namens "main" und startet dort. shuffle.c hat keine Funktion "main", und vorher kann kein ausführbares Programm erzeugt werden. Wir müssen es mit einem anderen Programm kombinieren, das eine Funktion "main" hat, und die Funktion "shuffle" aufruft.

Führe folgenden Befehl aus:

gcc -c shuffle.c

shuffle(&deck);

gcc -o game game.c

/tmp/ccmiHnJX.o: In function `main':
/tmp/ccmiHnJX.o(.text+0xf): undefined reference to `shuffle'
collect2: ld returned 1 exit status

Linken

Der Linker, ld, nimmt den Object-Code, welcher zuvor von as erzeugt wurde, und wandelt es in ein ausführbares Programm um mit dem Befehl

gcc -o game game.o shuffle.o

Der Linker findet die shuffle Funktion vom shuffle.o Objekt und fügt es in die ausführbare Datei ein. Das wirklich tolle an den Object-Files ist, dass, wenn wir die Funktion wieder verwenden wollen, wir nur noch die "deck.h" Datei einfügen und das shuffle.o Object-File zur neuen auszuführenden Datei dazulinken müssen.

Wiederverwendung von Code auf diese Art ist durchaus üblich. Wir haben nicht die printf Funktion geschrieben, die wir oben zum Debuggen verwendet haben, aber der Linker findet die Definitionen in dem File, das wir mit #include <stdlib.h> eingebunden haben, und zeigt zu dem Object-Code in der C-Bibliothek (/lib/libc.so.6). Auf diese Art können wir Funktionen von jemand anderem verwenden, ohne uns Sorgen zu machen, ob sie funktionieren, und uns um unsere eigenen Probleme kümmern. Dies ist der Grund, weshalb Header-Dateien normalerweise die Daten- und Funktionsdeklarationen, aber nicht die Funktionen selbst enthalten. Normalerweise machst Du Object-Files bzw. Bibliotheken für den Linker, um es ins Programm zu schreiben. Ein Problem könnte auftreten, da wir nicht alle Funktionsdefinitionen in unseren Header geschrieben haben. Was können wir tun, um zu überprüfen, ob alles in Ordnung ist?

Zwei weitere wichtige Optionen

Die -Wall Option schaltet alle Warnungen betreffend Syntax ein, damit wir sicher sein können, dass unser Code in Ordnung und so weit wie möglich portierbar ist. Wenn wir diese Option verwenden und unseren Code kompilieren, sehen wir etwas ähnliches wie:

game.c:9: warning: implicit declaration of function `shuffle'

void shuffle(deck_t *pdeck);

Eine weitere Compiler-Option ist die Optimierung. -O# (z.B.: -O2). Dies teilt dem Compiler mit, welche Stufe der Optimierung Du möchtest. Der Compiler hat eine Menge Tricks, um Deinen Code ein bißchen schneller zu machen. Bei kleinen Programmen wie unserem hier wirst Du keine Unterschiede merken, größere Programme jedoch werden etwas kleiner. Du wirst es überall sehen, deshalb solltest Du auch wissen, was es bedeutet.

Debuggen

Wie wir alle wissen, heißt es nicht, wenn unser Code kompiliert wird, dass er auch so arbeitet, wie wir wollen. Du kannst überprüfen, ob alle Nummern verwendet werden, wenn du folgendes ausführst

game | sort - n | less

gcc -g -c shuffle.c game.c
gcc -g -o game game.o shuffle.o

Zusammenfassung

Dieser Artikel war eine rasante Tour duch Kompilieren und Debuggen von C- Programmen. Wir diskutierten die Schritte, die der Compiler durchläuft und welche Optionen gcc verwendet, um diese Schritte zu machen. Wir streiften das Linken mit shared libraries und endeten mit einer Einführung über Debugger. Es nimmt viel Zeit in Anspruch, zu lernen, was Du tust, doch ich hoffe, dies hat dir geholfen, richtig zu beginnen. Mehr Informationen zu dem Thema findest Du im man und in den info Seiten für gcc, as und ld.

Selbst zu programmieren, lehrt am meisten. Zur Übung kannst Du die einfachen Anregungen für das Kartenspielprogramm in diesem Artikel verwenden und ein Black Jack Spiel programmieren. Nimm Dir die Zeit, um zu lernen, wie man den Debugger verwendet. Es ist viel einfacher mit einem GUI wie KDbg anzufangen. Wenn Du ein bißchen Funktionalität auf einmal einbringst, wirst Du fertig sein, bevor Du es merkst. Denk daran, halt es lauffähig!

Hier einige Dinge, die Du brauchen wirst, um ein vollständiges Spiel zu programmieren.

• Eine Definition eines Spielers (Du könntest z.B.: deck_t als einen player_t definieren).
• Eine Funktion, die eine bestimmte Anzahl von Karten an einen bestimmten Spieler austeilt. Denk daran, die Zahl der 'ausgespielten' im Blatt zu merken, damit Du weißt, von wo Du die nächste Karte nehmen sollst. Denk daran Dir zu merken, wieviele Karten ein Spieler in der Hand hat.
• Eine Abfrage, ob der Spieler eine weitere Karte möchte.
• Eine Funktion, um die Karten eines Spielers darzustellen. Der card -Wert ist % 13 (von 0 bis 12), der suit -Wert ist Wert / 13 (von 0 bis 3).
• Eine Funktion, um den Wert eines Blattes zu bestimmen. Asse haben die Nummer Null und können 1 oder 11 wert sein sein. Könige haben die Nummer 12 und den Wert 10.

Links

• gcc GCC GNU Compiler Collection
• gdb GNU Debugger
• KDbg KDE's GUI Debugger
• Award Winning Compiler Hack Ken Thompson's großer Compiler-Hack

Talkback für diesen Artikel

2002-02-13, generated by lfparser version 2.25