Weiter Zurück Inhaltsverzeichnis
Nachdem KDevelop erfolgreich installiert und die allgemeinen Einstellungen vorgenommen sind, möchten Sie wahrscheinlich wissen, ob die Entwicklungsumgebung hält, was sie verspricht. Dieses Kapitel gibt Ihnen einen Leitfaden, wie Programme allgemein mit den GNU Werkzeugen erzeugt werden und welchen Teil speziell KDevelop in diesem Prozeß übernimmt.
Der Compiler ist letztlich das Programm auf Ihrem System, das mindestens installiert sein muß um laufende Programme zu erzeugen; er ist derjenige, der den Quellcode in Objektdateien übersetzt und das Programm erzeugt.
Normalerweise würden Sie so starten: Öffnen Sie einen Editor Ihrer Wahl - benutzen Sie keine Textverarbeitung. Geben Sie etwa dieses ein, um den Quellcode Ihres ersten Programmes zu schreiben:
#include <iostream.h>
int main(){
cout << "Hello World" << endl;
}
Nun, alles, was das Programm tun wird, ist den String "Hello World" auf Ihrer Standardausgabe auszugeben. Aber dies ist nur der Quellcode für ein zu erstellendes Programm, nicht das Programm selbst. Daher benötigen Sie einen Compiler, in diesem Fall ein C++-Compiler wie etwa g++. Dann können Sie den Quellcode als Datei speichern, sagen wir als myprogram.cpp und den Compiler mit dem Dateinamen aufrufen (auf einer Konsole):
g++ -o myprogram myprogram.cpp
Danach können wir unser Programm starten- geben Sie einfach myprogram
auf der Konsole ein, und das Programm gibt den String aus
und beendet sich.
Ich habe jetzt alles, was ich brauche: einen Editor, einen Compiler und ich kann mein eigenes C++ Programm ausführen. Aber es ist nicht
ganz so einfach. Was passiert, wenn Sie mehr als eine Quellcodedatei haben ? Und, müssen Sie dann die Quellen immer wieder übersetzen,
wenn Sie nur eine Datei geändert haben ? Der Übersetzungsvorgang wird immer komplizierter und zeitraubender, weil Sie alle Kommandos
und Optionen selbst eintippen müssen. Deshalb können Sie sich ein sogenanntes "Makefile" schreiben. Man könnte es genausogut anders
nennen, außer dem Namen des Programms, das zu erstellen ist. Dann sollten Sie das Werkzeug make
oder gmake
installiert haben,
oder ein anderes Werkzeug, das den Übersetzungsvorgang überwacht. Fügen Sie alle Compileranweisungen in der speziellen
Erstellungssyntax in das Makefile ein und speichern Sie es; danach brauchen Sie nur noch make
oder gmake
auf der Konsole in
dem Verzeichnis einzugeben, wo sich das Makefile befindet; make übernimmt dann und bringt den Compiler dazu Ihr Programm zu erzeugen.
Das Make-Werkzeug hat noch viele weitere Vorteile und kann zu vielen Zwecken verwendet werden. Um eine Übersicht zu bekommen, öffnen
Sie eine Konsole und geben Sie ein:
man make
oder suchen Sie nach "GNU Make" in der KDE-Hilfe unter "System GNU Info contents".
Dies erklärt Ihnen, warum ein Entwickler das Make-Werkzeug beötigt, um den Ubersetzungsvorgang seiner Applikation zu vereinfachen. Nun, das schreiben der Makefiles ist jetzt nicht nur Handarbeit, Sie müssen sich auch noch in die Syntax und die Optionen hineinarbeiten. Aber hier ist die gute Nachricht über KDevelop und das Make-Werkzeug: Sie müssen nur das Make-Kommando im KDevelop Setup Dialog setzen und Sie sind soweit. Alle Projekte, die von KDevelop erzeugt werden, benutzen das Make-Kommando um die Zielapplikation zu erstellen, und Sie müssen nichts eingeben. Klicken Sie einfach auf den Make-Knopf in der Werkzeugleiste oder wählen Sie die gewünschte Funktion aus dem "Erstellen" Menü.
Die Werkzeugleiste und das "Erstellen"-Menü bieten die meist benutzten Funktionen, um make die Arbeit erledigen zu lassen:
Aber dies ist nicht das einzige, wo KDevelop mit make zusammenarbeitet- bei KDE Applikationen sind einige Dinge speziell auf die Unterstützung des Entwicklers abgestimmt wie die Erzeugung der Messages-Datei für die Internationalisierung Ihres Projekts. Diese Funktionen sind ebenfalls sorgfältig integriert, so daß Sie sich darüber nicht mehr den Kopf zerbrechen müssen.
Bis jetzt wissen Sie schon einiges über Quelldateien, den Compiler und warum make benötigt wird. Im nächsten Abschnitt werden wir
besprechen, warum Projekte, die mit KDevelop erstellt wurden, automatisch durch Verwendung eines configure
-Scripts auf den meisten
Unix-Plattformen übersetzt werden können.
Der Titel dieses Abschnitts- Configure, bedeutend soviel wie Konfiguriere - läßt Sie wahrscheinlich fragen: Konfiguriere ? Was muß konfiguriert werden ? Oder wer ?
Nun, gehen wir davon aus, daß Sie ein Programm geschrieben haben inklusive einem Makefile. Dann wollen Sie es verbreiten, aber die
compilierte Binärdatei läuft nur auf Ihrem System und auf solchen, die mit Ihrem kompatibel sind. Um andere Plattformen zu unterstützen
wie die verschiedenen Unix-Systeme oder Maschinen wie Alpha's oder RISC's müssen Sie ihr Programm neu übersetzen. Der einfachste Weg
wäre, das Quellpaket auf die Zielmaschine zu kopieren und make
nochmals laufen zu lassen. Aber was wäre, wenn die Zielmaschine
einen anderen Compiler benutzt oder in anderer Weise ein Problem erzeugt, die ein Erstellen des Programms verhindert ? Nicht zu
erwähnen die schwierigeren Dinge wie der Installationspfad für Ihr Programm und Dokumentation- z.B. kann KDE auf einer Maschine
unter opt/kde/ installiert sein, auf einer anderen aber unter
usr
local/kde/. In diesem Fall müßten Sie das Makefile immer
bearbeiten, um eine korrekte Übersetzung und Installation Ihres Produkts sicherzustellen.
Glücklicherweise haben die GNU-Werkzeuge noch mehr zu bieten als das mächtige make
- die allgemein genutzten Pakete automake und
autoconf. Es klingt gut, etwas mit "auto"- es scheint als ob etwas beim Applikations Design einfach und schnell gemacht werden kann,
was auch genau den Punkt trifft.
Der Zweck von automake
ist generell, die sogenannten Makefile.in
's aus der Datei Makefile.am
zu erstellen, die Sie für
Ihr Projekt anstatt einer "richtigen" Makefile schreiben müssen. Diese Makefile.am besteht aus Makros, die leicht interpretiert und die
Komplexität reduziert, die make anbietet, sodaß eine Makefile.am fehlerloser und schneller geschrieben werden kann als das letztliche
Makefile.
Aber wer erzeugt mir dann letztlich mein Makefile ? Nun, hier kommt autoconf. Autoconf benötigt verschiedene Makrodateien für das
Projekt. Diese sind die Makefile.in's, die automake erzeugt hat und eine Datei namesn configure.in
, die auch aus Makros besteht.
Hierbei beinhalten die Makefile.am und .in's die Makros die dafür verantwortlich sind, wie das Ziel erstellt wird in Bezug auf die
Quellen, die übersetzt werden müssen, welche Dateien zum Paket gehören und welchen Namen die letzliche Binärdatei oder Bibliothek nach
einem Erstellungsvorgang hat. configure.in
andererseits beinhaltet die Makros, nach denen das letztliche configure-Skript das System
prüft, auf denen configure ausgeführt wird. Dies können z.B. das Compiler-Kommando, benötigte Bibliotheken zu denen die letzliche
Binärdatei gelinkt wird und include-Dateien, die das Projekt benötigt, sein.
Wenn Sie z.B. eine KDE Applikation schreiben und nach der Fertigstellung Ihr Programm Benutzern zur Verfügung stellen möchten, muß
jeder Benutzer die Binärdatei selbst compilieren. Dann würden Sie eine configure.in
Datei, die die Makros für eine KDE-kompatible
Applikation enthält. Diese Makros werden dann expandiert zu einer Systemprüfung, ob die Qt-Bibliothek installiert ist, dem Pfad der
Qt-Headerdateien, den KDE Bibliotheken und Headern etc.
Zusammenfassung: Um eine GNU-gemäße Applikation zu erstellen, die auf verschiedene Unix-Betriebssysteme und andere Maschinen als Ihre eigene portabel sein soll, müssen Sie folgendes ausführen:
Dann ist die Hauptarbeit getan. Automake erzeugt die Makefile.in's, autoconf läuft über die configure.in
und Makefile.in
's und erzeugt
das ausführbare Shellscript configure
. Alles, was Sie dann zu tun haben, ist die Ausführung mit ./configure
, und das
Skript wird die Prüfungen durchführen. Schließlich werden die Makefiles erzeugt, die die Ausführung von make (oder gmake) erlauben, um
das Projekt zu erstellen.
Dies alles scheint ein bißchen viel zu sein, nur um eine kleine Applikation zu schreiben und auch viel zu lernen, speziell die korrekten Makros. Aber allein der Umstand, daß Sie damit einen Kompiliervorgang auf fast allen Unix-Systemen erreichen, macht die Arbeit früher oder später wett. Schließlich müssen Sie diese Arbeit auch nur einmal für das Projekt machen und im Fall, daß Ihre Projektdateien anwachsen, brauchen Sie ja nur die Dateinamen den Makros hinzufügen.
Nun, inwiefern unterstützt KDevelop diese Art der Applikationserstellung und wie kompliziert wird es für den Programmierer? Die gute Nachricht für Sie ist: Sie brauchen noch nicht eimal etwas über Makros und Skripte zu wissen. Alle Details sind hinter einer einfach zu bedienenden graphischen Benutzeroberfläche versteckt, die die Arbeit für Sie übernimmt. Eine Applikation wird mit den GNU-Tools deshalb auf sehr benutzerfreundliche Art erstellt:
Erzeugen Sie Ihre Applikation einfach mit dem KAppWizard nach Wahl der Bedürfnisse Ihrer Applikation- es mag ein reines C++ Terminalprogramm sein oder eine Art GUI Programm, das die Qt oder die Qt/KDE Bibliothek benutzt. Die ganze Arbeit wird für Sie erledigt und Ihr Projekt enthält schon die Makefiles, die durch eine automatische Ausführung der GNU-Tools und des configure-Skripts erstellt wurden.
Das wäre es schon- Sie brauchen nur die Quellen Ihres Projekts zu erweitern, sei es durch Hinzufügen von Klassen, Dialogen, Übersetzungen oder Dokumentation, was auch vollständig automatisiert abläuft. Konzentrieren Sie sich einfach auf die wirkliche Arbeit eines Entwicklers, nämlich Ihrer Applikation Funktionalität zu verleihen. In den meisten Fällen werden Sie wahrscheinlich nie mit Makefiles in Berührung kommen, wenn Sie KDevelop benutzen.
Der folgende Abschnitt betrachtet einen Terminus, der unter Entwicklern weit verbreitet ist: Debuggen. Das bedeutet, daß, obwohl Ihr
Compiler die letzliche Applikation erzeugt, das Programm aber nicht läuft oder während der Ausführung abstürzt wegen eines sogenannten
"Bugs" (Käfer) im Code. Ein Programmfehler, der mit dem Namen dieser Insekten beschrieben wird, stammt aus der Geschichte des
Computers; einer der ersten Fehler, die eine Maschine zum Absturz brachte, war keine offensichtliche Fehlfunktion- Käfer waren in den
Computer eingedrungen und waren dafür verantwortlich. Daher beschreibt man einen Fehler, der auf den ersten Blick nicht offensichtlich
ist, als einen "Bug", daher bedeutet "Debuggen", die Käfer zu entfernen, wo sie nicht hingehören. Nun, Sie brauchen sie nicht wirklich
zu jagen; vorausgesetzt daß die heutigen Computer konzipiert sind, diese durch einen Schutz fernzuhalten. Sie müssen innerhalb des
Codes gefunden werden, wenn sie die Ausführung eines Programms mit der Nachricht "Segmentation fault" (Speicherverletzung) beenden.
GNU bietet dazu ein weiteres Werkzeug, gdb
, den GNU Debugger. Dieses Terminalprogramm erlaubt es, die internen Werte einer
Applikation und die Ausführung durch setzen von Haltepunkten im Code zu beobachten. Gdb stoppt die Ausführung jedes mal, wenn das
Programm an einen Haltepunkt kommt. Aber wie die meisten Werkzeuge wird auch der debugger von einem anderen Programm gesteuert, das ein
Frontend dazu bietet und es erlaubt, die Werte einfach zu beobachten und Haltepunkte im Code zu setzen.
Zu diesem Zweck wird die Applikation Ihres Projekts standardmäßig mit der Compileroption zum Debuggen erzeugt und speichert daher zusätzliche Daten in der Binärdatei, um die Werte und Zeilen im Code zu lokalisieren. Als Frontend zu gdb benutzt KDevelop das Programm KDbg, den KDebugger. Um Ihr Programm zu debuggen, müssen Sie nur "Debuggen" im "Erstellen" Menü auswählen oder den entsprechenden Werkzeugleistenknopf betätigen, der durch ein Rad mit Brille dargestellt wird und signalisiert, das Sie die Ausführung beobachten wollen.
KDevelop öffnet dann das Werkzeuge-Fenster und startet Ihr Programm mit KDbg. Die KDbg Oberfläche erscheint dann innerhalb des Werkzeuge-Fensters und erlaubt die Benutzung genauso als ob Sie den Debugger außerhalb von KDevelop gestartet hätten.
Ganz allgemein zeigen die obigen Schritte, das ein Entwickler zum Schreiben seines eigenen Programms verschiedene Stufen durchlaufen
muß, um ein Projekt zu beginnen. Auch erklärt dies, welchen Teil KDevelop dabei übernimmt und wie die Entwicklungsumgebung die Idee eines einfachen Wegs
zur Unix-Programmierung unterstützt. Um weitere Informationen über die GNU Tools zu erhalten, sollten Sie die zugehörige Dokumentation
lesen, die Sie allgemein über das man
Kommando oder über "System GNU Info contents" in der KDE Hilfe nachschlagen können.
Weiter Zurück Inhaltsverzeichnis