Sebastian Bauer

Sebastian Bauer arbeitet als wissenschaftlicher Mitarbeiter am Klinikum Charité in Berlin. Erste Gehversuche mit Eclipse unternahm er während eines Praktikums bei IBM, das er im Rahmen seines Informatikstudiums durchführte. Seitdem ist ihm Eclipse bei der Softwareentwicklung ein ständiger Begleiter, den er nicht nur im Beruf einzusetzen weiß. In seiner Freizeit betreut er verschiedene Open-Source-Projekte für Amiga- Betriebssysteme. Zudem ist er seit 1999 Mitentwickler aktueller Versionen des Amiga- Betriebssystems. Als Autor veröffentlichte er Artikel über Eclipse und CDT im Amiga Magazin und im Eclipse Magazin. Zu diesem Buch sowie zu vielen weiteren dpunkt.büchern können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei dpunkt.plus + : www.dpunkt.de/plus

Sebastian Bauer Eclipse für C/C++-Programmierer Handbuch zu den Eclipse C/C++ Development Tools (CDT) 3., aktualisierte und erweiterte Auflage

Sebastian Bauer mail@sebastianbauer.info Lektorat: René Schönfeldt Copy-Editing: Annette Schwarz Satz: DaTeX, Leipzig Herstellung: Nadine Thiele Umschlaggestaltung: Helmut Kraus, www.exclam.de Druck und Bindung: Media-Print Informationstechnologie, Paderborn Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. ISBN Buch: 978-3-86490-196-6 PDF: 978-3-86491-785-1 epub: 978-3-86491-786-8 mobi: 978-3-86491-787-5 3., aktualisierte und erweiterte Auflage 2016 Copyright 2016 dpunkt.verlag GmbH Wieblinger Weg 17 69123 Heidelberg Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen. Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen. Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buches stehen. 5 4 3 2 1 0

Für G.

vii Vorwort Über Eclipse Der Ursprung von Eclipse liegt in VisualAge, IBMs Produktlinie von integrierten Entwicklungsumgebungen für eine Vielzahl verschiedener Programmiersprachen, darunter C, C++, Fortran, Java und Smalltalk. Anfänglich waren diese Programme in der Sprache Smalltalk geschrieben, die sich Mitte der 90er Jahre großer Beliebtheit erfreute. Durch das aufkeimende frei beziehbare Java verblasste die Popularität von Smalltalk jedoch recht schnell. So erblickte im Jahre 1999 VisualAge Micro Edition (VAME) das Licht der Welt, das als erstes Produkt der Reihe komplett auf Java aufsetzte. VAME selbst zielte auf Java-fähige eingebettete Systeme ab. Für seine Oberfläche nutzte VAME ein eigenes Toolkit, das Standard Widget Toolkit (SWT), was für Java-Applikationen sehr ungewöhnlich war, aber den Vorteil hatte, das native Feeling des Betriebssystems zu wahren. Ein flinker inkrementeller Java-Compiler wurde hinzugefügt und machte es möglich, dass Projekte zu jedem Zeitpunkt auch in übersetzter Form vorlagen. Unter der Haube war die IDE sehr flexibel, so konnte sie durch Plugins erweitert werden. Der richtige Erfolg wollte sich jedoch noch nicht einstellen. Die Erfahrungen, die die Entwickler in der VisualAge-Reihe sammelten, und das Framework von VAME flossen zusammen und mündeten schließlich in einem neuen Produkt, das IBM unter dem Namen Eclipse im November 2001 in die Öffentlichkeit trug. Die Ankündigung sorgte für viel Furore, denn im Gegensatz zu VisualAge wurden die Quellen offengelegt. IBM brüstete sich mit einer Wohltat an die Open-Source-Gemeinde: Der Wert der Quellen betrüge 40 Millionen US-Dollar. Der Name war zynisch gewählt, denn Eclipse (zu Deutsch: Finsternis) stand in direkter Konkurrenz zu NetBeans, das ein Jahr zuvor durch Java-Mutter Sun (zu Deutsch: Sonne) als Open Source zur Welt gebracht wurde und ebenfalls als IDE für Java um die Gunst der Entwickler buhlte. VisualAge 1999: VAME 2001: Eclipse

viii Vorwort Eine Plattform für alles und nichts im Besonderen Das Eclipse-Konsortium 2004: Eclipse wird gemeinnützig. Ab 2006: Koordinierte Veröffentlichung von Eclipse-Projekten Jupitermonde als Namensgeber Eclipse ließ sich jedoch nicht auf eine Java-IDE reduzieren. Das aus VAME vererbte, jedoch verbesserte Plugin-Konzept ebnete den Weg einer universellen Entwicklungsplattform.»The Eclipse Platform is an IDE for anything, and for nothing in particular«, hieß es zeitweilig auf http://www.eclipse.org. Zeitgleich zur ersten Veröffentlichung wurde das Eclipse-Konsortium eclipse.org von den Firmen Borland, IBM, MERANT, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft und Webgain gegründet. Fortan fasste dieses Konsortium die Entwicklung der Plattform unter einem Dach zusammen. Es schrieb sich auf die Fahne, alle beigesteuerten Produkte und deren Quellen unter die von der Open Source Initiative [18] akzeptierte Common Public License (CPL) zu stellen. Zahlreiche andere Hersteller schlossen sich mit der Zeit dem Konsortium an. Die Mitglieder verpflichteten sich neben der Leistung von Beiträgen auch zur Bereitstellung von Mitarbeitern. Auf der ersten, von da an jährlich stattfindenden Eclipse-Konferenz Anfang 2004 [9] wurde bekannt gegeben, dass das Konsortium zu einer unabhängigen Non-Profit-Organisation, der Eclipse Foundation, umorganisiert werden sollte. Man stellte die bis dato initiierten Projekte unter die Eclipse Public License (EPL), und die ohnehin schon große Gemeinde bekam weitere neue Mitglieder. Inzwischen zählt sie knapp 220 Unterstützer (Stand Juni 2015). Die Veröffentlichung von Eclipse findet zusammen mit weiteren Projekten wie der Java-Entwicklungsumgebung oder aber auch CDT seit dem Jahr 2006 synchronisiert statt. Die Zusammenfassung der sonst unabhängigen Projekte wurde vorgenommen, weil die Plattform Eclipse nicht nur stetige Erweiterungen erfuhr, sondern auch tiefgreifende Änderungen im Kern umfasste, die in Teilen Inkompatibilitäten zu vorherigen Revisionen verursachten. Benutzer können zumindest von den unter gleicher Bezeichnung veröffentlichten Paketen sicher sein, dass sie ohne solche auftretenden Kompatibilitätsprobleme miteinander harmonieren. In der Regel folgen einer koordinierten Veröffentlichung innerhalb eines Jahres zwei sogenannte Service-Releases, die fast ausschließlich Bugfixes beinhalten, zumindest was die Eclipse-Plattform angeht, bevor im Sommer des nächsten Jahres der neue Zyklus beginnt. Die Zyklen trugen in der Vergangenheit zunächst die Namen von Jupitermonden: Callisto (2006, 10 Projekte), Europa (2007, 21 Projekte) und Ganymede (2008, 24 Projekte). Von diesem Namensschema verabschiedete man sich bereits im Jahr 2009, da man befürchtete, dass die Anzahl der Jupitermonde (von denen laut Wikipedia heute mindestens 67 bekannt sind) nicht hoch genug ist. So ließ es sich jedenfalls ein Eclipse-Entwickler in einem Interview im Eclipse-Magazin [3] entlocken:

Vorwort ix We changed the naming scheme because we were concerned that we were going to run out of names long before we ran out of steam on the release train... 80 60 Abb. 1 Anzahl der Eclipse- Projekte, die bei den jährlichen Veröffentlichungen teilnahmen Projekte 40 20 0 Callisto Europa Ganymede Galileo Helios Indigo Juno Kepler Luna Mars 2006 2009 2012 2015 Jahr Der Release-Zyklus von 2009, der 33 Projekte beinhaltete, erhielt schließlich den Namen Galileo, zu Ehren jenes italienischen Astronoms, der 400 Jahre zuvor mit einem selbst gebauten Fernrohr u. a. die bisherigen Namensgeber entdeckte. Über die folgenden Zyklen gibt Abbildung 1 Aufschluss. Hervorzuheben ist dabei das Juno-Release, das ganz im Zeichen der neuen Eclipse-4-Plattform stand, die jedoch anfänglich insbesondere aufgrund von Performance-Regressionen durch eher negative Schlagzeilen auf sich aufmerksam machte [16]. Inzwischen sind diese aber weitgehend behoben. Auch Features wie die Möglichkeit des Umsortierens von Perspektiven, die die Eclipse-Plattform vor Version 4.0 mit sich brachte, sind spätestens seit Luna wieder verfügbar, die Vorgängerversion von Mars, auf der dieses Buch basiert. Koppelte man zu Beginn den Veröffentlichungszyklus der teilnehmenden Projekte tatsächlich fest an den Zyklus der koordinierten Veröffentlichungen, ist es inzwischen nicht unüblich, dass einzelne Projekte Weitere Entwicklung Lockerung in der Projekteveröffentlichung

x Vorwort pro Eclipse-Jahr häufigere stabile Veröffentlichungen vornehmen. Bei CDT einigte man sich, bis zu zwei Zwischenversionen außerhalb des jährlichen Zyklus einzuschieben, die Teil der Service-Releases sind. Beispielsweise beinhaltete die erste Luna-Veröffentlichung im Jahr 2014 CDT 8.4, während das zweite Service-Release von Luna, das im Februar 2015 fertiggestellt wurde, CDT 8.6 beinhaltete. Über CDT Entstehung von CDT Aktuelle Version Ein halbes Jahr nach der ersten Veröffentlichung von Eclipse legte Konsortiums-Gründungsmitglied und Echtzeitbetriebssystem-Spezialist QNX Teile der Quellen seiner QNX Momentics Development Suite offen. QNX kündigte an, die Suite in das Eclipse-Framework einzufügen, und übernahm auch die Leitung des jungen CDT-Projekts, das zum Ziel hat, Eclipse mit einer flexiblen Unterstützung der Programmiersprachen C und C++ zu ergänzen. Im April 2003 folgte dann die erste Veröffentlichung von CDT für Eclipse 2.0. So wurde die Behauptung, Eclipse sei eine Mehrsprachenplattform, das erste Mal Realität: Neben einfachem Syntax Highlighting für C und C++ integrierte man die GNU-Toolchain, wobei auch der Debugger nicht ausgelassen wurde. CDT war auch Teil der ersten koordinierten Veröffentlichung der Eclipse-Projekte im Jahr 2006, zu der es CDT schon bis zur Version 3.1 geschafft hatte. 2010 wurde bereits Version 7.0 veröffentlicht, und seit Juni 2015 liegt CDT in Version 8.7 vor, die auch Gegenstand dieses Buchs ist. Der schnelle Sprung zu hohen Versionsnummern zeigt, dass CDT eine sehr dynamische Entwicklung hinter sich hat. CDT macht vom Angebot der Eclipse-Plattform Gebrauch, eigene spezifische Erweiterungspunkte bereitzustellen. Das erlaubt auch für CDT ein gewisses Maß an Flexibilität. So ist es für einen Anbieter einer Compiler-Suite sehr leicht möglich, diese in das Eclipse-/CDT- Framework einzubinden. Zielsetzung des Buchs Es sind bereits zahlreiche Bücher über Eclipse erschienen. Schaut man sich den Markt jedoch genauer an, so stellt man schnell fest, dass sich die meisten Werke dem Produkt Eclipse nur in Zusammenhang mit der Java-Entwicklung nähern. Andere Plugins oder andere Programmiersprachen finden, wenn überhaupt, nur am Rande Erwähnung. Dieses Buch möchte die Lücke für die Programmiersprache C und ihren Abkömmling C++ schließen und den Leser in die Benutzung von Eclipse und CDT einführen.

Vorwort xi Kenntnisse über Eclipse sind nicht notwendig. Weiterhin ist es unerheblich, in welcher Art und Weise der Leser seine C- oder C++-Projekte bisher verwirklicht hat, sei es mittels einer Entwicklungsumgebung wie Microsofts Visual Studio oder ganz traditionell über Texteditor, Make und Kommandozeile. In die Programmiersprachen C und C++ kann das Buch jedoch nicht einführen. Hierfür existiert bereits sehr gute und umfangreiche Literatur [14], die teilweise sogar kostenlos angeboten wird, wie z. B. im Falle des Wikibooks C-Programmierung, auf das unter der URL http://de.wikibooks.org/wiki/c-programmierung zugegriffen werden kann. Die Handhabung von Werkzeugen, die unmittelbar mit der Programmiersprache assoziiert sind, wie z. B. Make, steht ebenso wenig im Vordergrund. Dennoch ist das Buch auch für C- oder C++-Einsteiger als Ergänzung zu einem Einführungsbuch von Interesse, da eine Umgebung wie CDT dem Entwickler jede Menge Hilfestellungen in den einzelnen Entwicklungsphasen liefert und es ihm erlaubt, sich auf das Wesentliche zu konzentrieren. Gerade Neulinge werden dies als praktisch empfinden. Beispielsweise sind Kenntnisse über das erwähnte Make bei vielen Projekten gar nicht nötig. Das Buch beschreibt CDT in seiner rohen Form, so wie es von eclipse.org heruntergeladen werden kann. Erweiterungen, die in den CDT-basierten Entwicklungsumgebungen von Drittanbietern zu finden sind, spielen nur eine geringe Rolle. Da das Buch eine benutzerorientierte Einführung darstellt, wird auch die Beschreibung der API außen vor gelassen, die ausschließlich für die Entwicklung von Erweiterungen für CDT von Bedeutung ist. Ein solches Vorhaben erfordert selbstverständlich Kenntnisse über viele Konzepte und Abläufe von CDT, auf die in den entsprechenden Abschnitten detailliert eingegangen wird. Insofern werden Sie auch als potenzieller Plugin-Anbieter von der Lektüre profitieren können. Vorkenntnisse Keine Einführung in C oder C++ Hauptsächlich CDT»pur«Buchaufbau Die Grobgliederung des Buchs besteht aus drei Teilen. Der erste Teil führt Sie in die Welt von Eclipse und CDT ein. Los geht s mit einer Installationsbeschreibung, die je nach verwendeter Plattform und Anforderung mehr oder weniger kompliziert durchgeführt werden muss. Anschließend werden Sie in die Begriffe und die wichtigsten Prozeduren anhand eines eingängigen Beispiels eingeführt. So können Sie bereits nach kurzer Zeit einfache C- oder C++-Projekte mit Eclipse/CDT erstellen, bearbeiten, übersetzen, ausführen und debuggen. Einführung

xii Vorwort CDT als Unterstützer in den einzelnen Phasen des Entwicklungsprozesses Weiterführende Themen Der zweite Teil orientiert sich an den einzelnen Phasen, die ein C- oder C++-Programmierer zu bewerkstelligen hat, damit am Ende ein lauffähiges Produkt zustande kommt. Es wird aufgezeigt, was mit Eclipse/CDT derzeit möglich ist, bei welchen Problemen Ihnen diese Kombination Hilfestellungen geben kann und was derzeit noch nicht oder nur unzureichend implementiert ist. Zusätzlich zu der Beschreibung der Bedienung werden konkrete Problemstellungen aufgezeigt, die unter Zuhilfenahme kleiner Beispiele eine Lösung finden. Der dritte Teil widmet sich schließlich weiterführenden Themen. Sie werden z. B. erfahren, wie Sie Ihre Projekte mit Eclipse in einem Team organisieren, mit Hilfe von zusätzlichen Plugins aufgabenfokussierte Entwicklung betreiben oder Debugging-Tools wie Valgrind in den Entwicklungsprozess einbeziehen. Terminologie Eclipse ist internationalisiert und kann so theoretisch in anderen Sprachen als Englisch betrieben werden. Allerdings wurde bisher nur für die Version 3.2 von Eclipse ein komplettes Sprachpaket durch IBM gesponsert, das für aktuelle Versionen nur beschränkte Gültigkeit hat. Aus diesem Grund wird hier mit der englischen Version des Programmpakets gearbeitet. Die im Buch verwendete Terminologie, z. B. bei der Beschreibung von Benutzeroberflächenelementen, ist deshalb ebenso an die englischen Fachausdrücke angelehnt, wenn dafür keine adäquate Übersetzung bekannt ist. Webseite und Kontakt Zum Buch existiert eine Webseite, die Sie unter http://www.dpunkt.de/buecher/4680.html abrufen können. Neben den Quelltexten und einer Errata-Liste sind dort alle im Buch aufgeführten Verweise auf Webressourcen verzeichnet. Zusätzlich finden Sie einen Katalog von Eclipse-Erweiterungen, die besonders C- oder C++-Programmierer interessieren könnten. Haben Sie Fragen zum Buch, einen Fehler entdeckt, Vorschläge oder Kritiken? Dann können Sie mir unter mail@sebastianbauer.info eine Nachricht zukommen lassen.

xiii Inhaltsverzeichnis I Einstieg in Eclipse und CDT 1 1 Installation.......................................... 3 1.1 C- und C++-Compiler...................................... 3 1.2 Das richtige Eclipse-Archiv finden.......................... 4 1.3 Installation unter Linux..................................... 6 1.3.1 Compiler und Tools................................. 7 1.3.2 Java................................................ 7 1.3.3 Eclipse.............................................. 8 1.4 Installation unter Windows................................. 8 1.4.1 Compiler und Tools................................. 8 1.4.2 Java................................................ 13 1.4.3 Eclipse.............................................. 13 1.5 Die Eclipse.ini-Datei........................................ 14 1.6 Willkommen............................................... 16 1.7 Eclipse erweitern.......................................... 17 1.7.1 CDT nachträglich installieren........................ 18 1.7.2 Update-Sites........................................ 20 1.7.3 Features verwalten.................................. 22 1.7.4 Die CDT-Features im Detail.......................... 23 1.7.5 Eclipse Marketplace................................. 24 1.7.6 p2.................................................. 27 2 Erste Schritte........................................ 29 2.1 Konzepte des Eclipse-Frameworks.......................... 29 2.1.1 Workspace.......................................... 29 2.1.2 Ressourcen......................................... 30 2.1.3 Eclipse-Workbench.................................. 30 2.1.4 Menüleiste.......................................... 30 2.1.5 Werkzeugleiste..................................... 31 2.1.6 Statusleiste......................................... 32 2.1.7 Editoren und Views.................................. 33 2.1.8 Perspektiven........................................ 34

xiv Inhaltsverzeichnis 2.2 Das erste Projekt........................................... 36 2.2.1 Eclipse anpassen.................................... 36 2.2.2 Vorgehensweise.................................... 38 2.2.3 Ein neues Projekt anlegen........................... 38 2.2.4 Die Quelldatei erzeugen............................. 38 2.2.5 Übersetzen......................................... 40 2.2.6 Ausführen.......................................... 42 2.2.7 Programmfehler aufspüren.......................... 42 2.2.8 Zusammenfassung und Ausblick..................... 44 2.3 Das Eclipse-Hilfesystem.................................... 45 2.3.1 Dokumentationsaufbau............................. 45 2.3.2 Hilfefenster......................................... 46 2.3.3 Kontextbezogene Hilfe.............................. 48 2.4 Eclipse über die Tastatur steuern............................ 49 2.5 Nützliche Einstellungen.................................... 50 2.5.1 Voreinstellungsdialog............................... 50 2.5.2 Hierarchie der Voreinstellungen...................... 51 2.5.3 Allgemeine Workspace-Einstellungen................ 52 2.5.4 Workspace-Auswahl beim Starten und Beenden...... 54 2.5.5 Netzwerkeinstellungen.............................. 55 2.5.6 Einstellungen für SSH-Client......................... 55 2.5.7 Passwortspeicher................................... 57 2.5.8 Komponenten (de-)aktivieren........................ 57 2.6 Die Benutzerschnittstelle anpassen......................... 58 2.6.1 Werkzeug- und Menüleiste anpassen................. 59 2.6.2 Perspektiven verwalten.............................. 62 2.6.3 Tastatursteuerung anpassen......................... 62 2.6.4 Erscheinungsbild.................................... 64 2.7 Verzeichnislayout auf dem Datenträger..................... 65 2.7.1 Programmverzeichnis............................... 65 2.7.2 Workspace.......................................... 67 II Entwicklung mit CDT 69 3 Projekte erstellen und bearbeiten...................... 71 3.1 Konzepte von CDT......................................... 72 3.1.1 Parser.............................................. 72 3.1.2 Indexer............................................. 72 3.1.3 Piktogramme....................................... 73 3.1.4 Kurze Einführung in das Build-System................ 74

Inhaltsverzeichnis xv 3.2 C- oder C++-Projekte erzeugen............................. 75 3.2.1 Projekte anlegen.................................... 76 3.2.2 Dateien erzeugen................................... 79 3.2.3 Verzeichnisse hinzufügen............................ 84 3.2.4 Vorhandene Projekte importieren.................... 85 3.2.5 Projekt entfernen................................... 88 3.2.6 Projekttyp ändern................................... 88 3.3 Eigenschaften von Ressourcen............................. 89 3.4 Projekt: Dirscanner......................................... 91 3.4.1 Boost installieren.................................... 92 3.4.2 Dirscanner entwickeln............................... 94 3.5 Quelltexte bearbeiten...................................... 99 3.5.1 Grundsätzlicher Aufbau eines Editorfeldes............ 99 3.5.2 Textpassagen markieren............................. 99 3.5.3 Quelltext formatieren............................... 100 3.5.4 Editierhilfen........................................ 101 3.5.5 Präsentation der Quelltexte.......................... 101 3.5.6 Annotationen....................................... 105 3.5.7 Code-Analyse....................................... 107 3.5.8 Navigation.......................................... 109 3.5.9 Content-Assistenz................................... 110 3.5.10 Makros untersuchen................................ 113 3.5.11 Suchen und Ersetzen................................ 115 3.5.12 Include-Direktiven organisieren...................... 118 3.5.13 Setters und Getters erzeugen........................ 120 3.5.14 Methode implementieren........................... 120 3.5.15 Kommentare für externe Dokumentationswerkzeuge. 121 3.5.16 Bookmarks......................................... 123 3.5.17 Makefile............................................ 124 3.5.18 Undo/Redo-Funktion................................ 124 3.6 Dateienvergleich.......................................... 125 3.6.1 Zwei Dateien vergleichen............................ 125 3.6.2 Drei Dateien vergleichen............................ 128 3.6.3 Lokale Historie...................................... 128 3.7 Working-Sets.............................................. 129 3.7.1 Ein Working-Set erstellen............................ 130 3.7.2 Working-Sets einschalten............................ 132 3.7.3 Workbench-Working-Sets........................... 132 3.8 Tasks...................................................... 133 3.8.1 Tasks hinzufügen.................................... 133 3.8.2 Tasks mit Schlüsselwörtern.......................... 134 3.8.3 Tasks anzeigen lassen............................... 134

xvi Inhaltsverzeichnis 3.9 Refactoring................................................ 135 3.9.1 Ressourcen umbenennen........................... 136 3.9.2 Bezeichner umbenennen............................ 136 3.9.3 Konstanten extrahieren............................. 140 3.9.4 Lokale Variablen extrahieren......................... 141 3.9.5 Eine Funktion oder Methode extrahieren............. 142 3.9.6 Funktionsdefinition umplatzieren.................... 144 3.9.7 Methoden verstecken............................... 144 3.9.8 Historie der Refactorings............................ 145 3.10 Parser- und Indexerdetails.................................. 146 3.10.1 Parser.............................................. 146 3.10.2 Indexeroptionen anpassen.......................... 148 3.10.3 Weitere Indexer-Parameter.......................... 151 3.10.4 Indexdatenbank analysieren......................... 152 3.10.5 Probleme mit dem Indexer.......................... 153 3.11 Nützliche Views der C/C++-Perspektive..................... 154 3.11.1 Outline............................................. 154 3.11.2 Include Browser..................................... 155 3.11.3 Call Hierarchy....................................... 157 3.11.4 Type Hierarchy...................................... 158 3.12 Navigations-Views......................................... 159 3.12.1 Navigator........................................... 160 3.12.2 C/C++ Project....................................... 161 3.12.3 Project Explorer..................................... 162 3.13 Ressourcen finden......................................... 163 3.14 Elemente finden........................................... 163 3.15 Suchen und Ersetzen....................................... 165 3.15.1 File Search.......................................... 166 3.15.2 C/C++ Search....................................... 167 3.16 Eine Frage des Stils........................................ 169 3.16.1 Allgemeine Einstellungen........................... 169 3.16.2 Quelltextformatierung.............................. 169 3.16.3 Quelltextschablonen................................ 171 3.16.4 Namens- und Bezeichnerkonventionen.............. 172 3.16.5 Include-Direktiven organisieren...................... 173 3.17 Editorschablonen.......................................... 174 3.18 Projektspezifische Metadateien............................. 176 3.18.1 Metadateien im Projektverzeichnis................... 176 3.18.2 Metadateien im Workspace-Verzeichnis.............. 177

Inhaltsverzeichnis xvii 4 Der Build-Prozess.................................... 179 4.1 Builder.................................................... 180 4.1.1 Die vier Modi eines Builders......................... 180 4.1.2 Builder-Assoziationen............................... 181 4.1.3 Builder-Konfiguration............................... 182 4.1.4 Zwei Builder für C/C++-Projekte...................... 183 4.2 Build-Variablen............................................ 184 4.2.1 Eigenschaften von Build-Variablen................... 184 4.2.2 Build-Variablen benutzen............................ 185 4.2.3 Gültigkeitsbereich von Build-Variablen............... 185 4.2.4 Workspace-weite Build-Variablen definieren.......... 187 4.2.5 Umgebungsvariablen als Build-Variablen............. 188 4.2.6 Dynamische Build-Variablen......................... 188 4.3 Kontrolle über Managed Build.............................. 189 4.3.1 Konfigurationen verwalten.......................... 189 4.3.2 Quellverzeichnisse.................................. 189 4.3.3 Dateien vom Build-Prozess ausschließen............. 191 4.3.4 Custom Build....................................... 191 4.4 Einstellungen für C/C++-Projekte........................... 192 4.4.1 C/C++ Build......................................... 193 4.4.2 Paths and Symbols.................................. 196 4.4.3 Preprocessor Include Paths, Macros.................. 197 4.4.4 Environment........................................ 201 4.4.5 Logging............................................ 203 4.4.6 Settings............................................ 203 4.4.7 Tool Chain Editor.................................... 209 4.4.8 Build Variables...................................... 212 4.5 Einstellungen für Ressourcen............................... 212 4.5.1 Settings............................................ 213 4.5.2 Tool Chain Editor.................................... 215 4.5.3 Path and Symbols................................... 216 4.5.4 Preprocessor Include Paths, Macros.................. 216 4.6 Makefile-Projekte.......................................... 217 4.6.1 Der Make Targets-View............................... 217 4.6.2 Make Targets hinzufügen............................ 218 4.6.3 Make Targets aufrufen............................... 219 4.6.4 Make Targets entfernen............................. 219 4.6.5 Besonderheiten..................................... 220 4.7 Compiler-Ausgaben....................................... 220 4.7.1 Console............................................ 220 4.7.2 Voreinstellungen zur Build-Konsole.................. 222 4.7.3 Wie CDT Kommandoausgaben verarbeitet........... 222 4.7.4 Error Parser festlegen................................ 223

xviii Inhaltsverzeichnis 4.7.5 Übersetzungsfehler finden.......................... 225 4.7.6 Fehler filtern........................................ 226 4.8 Code-Generatoren verwenden............................. 227 4.8.1 Beispiel: mathematische Ausdrücke auswerten....... 228 4.8.2 Bison installieren.................................... 230 4.8.3 Projekt erstellen und Quelltexte einpflegen........... 230 4.8.4 Einstellungen anpassen............................. 233 4.8.5 Projekt übersetzen und ausführen................... 235 4.8.6 Als Projekt mit Makefile.............................. 235 4.8.7 Fazit................................................ 236 4.9 Cross-Compiling........................................... 237 4.9.1 Cross-Compiling für Make-Projekte.................. 237 4.9.2 Cross-Compiling für Managed Build.................. 237 4.9.3 Beispiel: AmigaOS4................................. 238 4.9.4 Cross-Compiling-Plugin............................. 240 4.10 Remote Compiling......................................... 240 4.10.1 Das Programm ssh einrichten........................ 241 4.10.2 Das Dateisystem einrichten.......................... 242 4.10.3 Ein Remote-Build-Kommando erstellen.............. 243 4.10.4 Remote Compiling in Eclipse anwenden.............. 244 4.11 Microsoft Visual C++ einbinden............................ 245 4.11.1 Visual C++ installieren............................... 246 4.11.2 Das Projekt einrichten............................... 248 4.11.3 Den Build-Prozess anpassen......................... 249 5 Ausführen und Debugging............................ 255 5.1 Programmstartdialoge..................................... 256 5.1.1 Main............................................... 258 5.1.2 Arguments......................................... 258 5.1.3 Environment........................................ 259 5.1.4 Common........................................... 259 5.2 Doxygen einbinden........................................ 261 5.2.1 Konfigurationsdatei anlegen......................... 261 5.2.2 Doxygen-Tool einrichten............................ 262 5.2.3 Doxygen aufrufen................................... 263 5.3 Die Launch-Konsole........................................ 264 5.4 Programme debuggen..................................... 265 5.4.1 Programme im Debug-Modus starten................ 265 5.4.2 Debug-Launcher.................................... 266 5.4.3 Debugger konfigurieren............................. 267 5.4.4 Debug-Perspektive.................................. 269 5.4.5 Quelltexte lokalisieren............................... 269 5.4.6 Der Debug-View.................................... 271

Inhaltsverzeichnis xix 5.5 Den Programmablauf gezielt unterbrechen................. 275 5.5.1 Breakpoints-View................................... 275 5.5.2 Zeilen-Breakpoints.................................. 277 5.5.3 Funktions-Breakpoints.............................. 278 5.5.4 Data-Breakpoints................................... 279 5.5.5 Address-Breakpoints................................ 280 5.5.6 Event-Breakpoints................................... 280 5.5.7 Eigenschaften von Breakpoints...................... 281 5.5.8 Dynamisches Printf.................................. 284 5.6 Nützliche Views beim Debuggen........................... 285 5.6.1 Variables........................................... 285 5.6.2 Expressions......................................... 288 5.6.3 Register............................................ 290 5.6.4 Disassembly........................................ 291 5.6.5 Signale............................................. 292 5.6.6 Memory............................................ 293 5.6.7 Executables......................................... 296 5.6.8 OS Resources....................................... 297 5.7 Reverse Debugging........................................ 297 5.7.1 Reverse Debugging einschalten..................... 298 5.7.2 Kontrollfluss steuern................................ 298 5.7.3 Beispiel: Binäre Suche mit einem Vergleich........... 299 5.8 Unit Testing............................................... 302 5.8.1 Boost-Test-Library benutzen......................... 302 5.8.2 Test starten......................................... 304 5.9 Auf entfernten Rechnern debuggen........................ 305 5.10 Tracepoints................................................ 307 5.10.1 Tracepoints hinzufügen............................. 307 5.10.2 Tracepoint-Aktionen................................ 307 5.10.3 Traces auswerten................................... 309 5.11 Launch Groups............................................ 310 III Weitere nützliche Plugins 313 6 Versionsverwaltung mit EGit.......................... 315 6.1 Grundlagen............................................... 316 6.1.1 Motivation.......................................... 316 6.1.2 Begriffe............................................. 318 6.1.3 Konzepte von Git.................................... 319 6.2 EGit installieren............................................ 320 6.3 EGit konfigurieren......................................... 322 6.4 Die Perspektive Git......................................... 323

xx Inhaltsverzeichnis 6.5 Bestehende Projekte mit Git assoziieren..................... 324 6.6 Ein entferntes Repository klonen........................... 325 6.7 Projekt in den Workspace importieren...................... 327 6.8 Dekorationen.............................................. 328 6.9 Mit Projekten unter Git arbeiten............................ 329 6.10 Versionen vergleichen..................................... 337 6.11 Änderungsanzeige mit Git................................. 338 6.12 Historie................................................... 338 6.13 Arbeiten mit Entwicklungszweigen......................... 340 6.14 Rebase.................................................... 344 6.15 Konflikte lösen............................................. 347 6.16 Stash...................................................... 348 6.17 Weitere Informationen zu Git............................... 349 7 Mylyn............................................... 351 7.1 Mylyn installieren.......................................... 352 7.2 Einführendes Beispiel...................................... 353 7.3 Konzepte.................................................. 356 7.4 Task Connectors........................................... 357 7.4.1 Bugzilla............................................. 357 7.4.2 SourceForge........................................ 360 7.4.3 GitHub............................................. 363 7.5 Weitere Konnektoren...................................... 365 8 Target Management.................................. 367 8.1 Target-Management-Plugin installieren..................... 367 8.2 Konzepte.................................................. 368 8.3 Die Perspektive Remote System Explorer..................... 369 8.4 Der Remote Systems-View.................................. 370 8.5 Der Remote Monitor-View.................................. 371 8.6 Eine neue Verbindung anlegen............................. 371 8.7 Die Verbindung aktivieren.................................. 374 8.8 Durch Ressourcen navigieren............................... 374 8.9 Filter und Filterpools erzeugen............................. 375 8.10 Profile verwalten........................................... 376 8.11 Ein Projekt auf den entfernten Rechner exportieren.......... 377 8.12 Entfernte Projekte......................................... 377 8.13 DataStore................................................. 378 8.13.1 DataStore auf Linux einrichten....................... 378 8.13.2 DataStore auf Windows einrichten................... 379 8.14 Den entfernten Rechner (fern-)steuern...................... 379 8.14.1 Kommandos aufrufen............................... 379 8.14.2 Terminals........................................... 379

Inhaltsverzeichnis xxi 8.15 Programme auf dem entfernten Rechner ausführen.......... 380 8.15.1 Programme auf entfernten Rechnern starten......... 381 8.15.2 Beispiel: Cross-Development für Raspberry Pi......... 381 8.15.3 Projekt auf dem Pi über Eclipse debuggen............ 385 9 Autotools........................................... 387 9.1 Autotools-Plugin installieren............................... 387 9.2 Autotools-Projekt erzeugen................................ 387 9.3 Editoren für Autotools-Dateien............................. 388 9.4 Autotools-Projekte übersetzen............................. 389 9.5 Autotools manuell aufrufen................................ 389 9.6 Globale Voreinstellungen.................................. 390 9.7 Projekteinstellungen....................................... 390 10 Linux-Tools.......................................... 391 10.1 Linux-Tools installieren..................................... 391 10.2 Valgrind-Plugin............................................ 392 10.2.1 Hintergründe....................................... 392 10.2.2 Erste Schritte....................................... 393 10.3 Profiling-Kategorien....................................... 396 10.4 Andere Valgrind-Tools...................................... 397 10.4.1 Valgrind-Tools konfigurieren......................... 397 10.4.2 Heap mit massif analysieren......................... 398 10.4.3 Cache-Zugriffe mit cachegrind ermitteln.............. 400 10.5 Profiling mit GProf......................................... 402 10.6 Docker Tooling............................................ 403 10.6.1 Verbindung zur Docker-Instanz einrichten............ 404 10.6.2 Docker-Images...................................... 405 10.6.3 Programm auf Docker-Container ausführen.......... 406 10.7 Weitere Plugins............................................ 407 Anhang 409 Literaturverzeichnis........................................ 411 Glossar.................................................... 413 Index..................................................... 415

Teil I Einstieg in Eclipse und CDT 7

3 1 Installation Dieses Kapitel beschreibt die Installation der IDE. Da sich die Voraussetzungen je nach Art des Betriebssystems unterscheiden, wird nach einer zunächst allgemeinen Einführung in die von CDT unterstützten Compiler die Installation unter Linux und Windows in zwei getrennten Abschnitten behandelt. Falls Sie Eclipse bereits benutzen, beispielsweise für Java-Projekte, sind für Sie wahrscheinlich nur die Abschnitte 1.3.1 bzw. 1.4.1 und 1.7.1 von Interesse. Sowohl Eclipse als auch CDT laufen auf weiteren Plattformen, auf die in diesem Buch jedoch nicht explizit eingegangen wird, hauptsächlich weil dem Autor eine solche Plattform nicht zur Verfügung stand. Zu diesen Plattformen zählt auch Mac OS X bzw. OS X, für das Eclipse ab Version 3.5 sowohl die klassische Carbon-Schnittstelle nutzt als auch in einer Cocoa-Implementierung vorliegt. Die Installation sollte hier allerdings ähnlich der Linux-Variante verlaufen. OS X 1.1 C- und C++-Compiler Im Unterschied zu den Java Development Tools (JDT), die einen eigenen Java-Compiler integriert haben, bringt das CDT in der standardmäßigen Auslieferung keinen C/C++-Compiler mit sich. Vielmehr agiert CDT als Frontend für eine Reihe von Compilern. Dabei werden in der Version 8.7 von CDT die C/C++-Compiler der GNU Compiler Collection, ihre Windows-Portierung MinGW sowie optional, d. h. über weitere Zusatzpakete, Clang sowie IBM XL C/C++ unterstützt, auf die in diesem Buch aber nicht eingegangen wird. C-Dialekterweiterungen wie Unified Parallel C können Sie auf diese Weise gleichfalls benutzen. Wie Sie später sehen werden, ist es auch möglich, andere Übersetzungsprogramme wie z. B. Visual C++ einzubinden, wenngleich schon hier deutlich gemacht werden soll, dass diese Variante stark an Komfort zu wünschen übrig lässt, sofern die Anbindung nicht über ein Zusatzpaket realisiert ist. Für Visual C++ lag ein solches Zusatzpaket bei Drucklegung noch nicht vor.

4 1 Installation 1.2 Das richtige Eclipse-Archiv finden Eclipse/CDT-Paket finden Seit der Europa-Veröffentlichung im Juli 2007 existieren bereits auf verschiedene Entwicklerbedürfnisse zugeschnittene Pakete, die neben dem Hauptprogramm auch gleich die notwendigen Features und Plugins für ein bestimmtes Aufgabengebiet beinhalten. Im Besonderen existiert auch ein solches für die C- oder C++-Entwicklung, das nun heruntergeladen werden soll. Ausgehend von http://www.eclipse.org/ folgen Sie einem Download-Link, um auf eine Seite mit der Adresse http://www.eclipse.org/downloads/ zu gelangen. Dort werden die für spezielle Aufgabengebiete zusammengeschnürten Pakete präsentiert, wie in Abbildung 1-1 zu sehen ist. Die hier interessante Variante verbirgt sich freilich unter Eclipse IDE for C/C++ Developers. Der Link führt über eine Mirror-Seite zum Archiv, das Sie am besten jetzt herunterladen. In der Regel sind die darin enthaltenen Dateien auf Ihrer Plattform lauffähig. Schlägt die korrekte Erkennung Ihrer Systemkonfiguration im Browser jedoch fehl, dann führen die Links zum Ziel, die in der Abbildung eingekreist sind. Sobald das Archiv erfolgreich heruntergeladen worden ist, können Sie je nach Betriebssystem zur nächsten oder übernächsten Sektion im Buch übergehen. Abb. 1-1 Ausschnitt der Downloadseite vom Juli 2015. Der untere Kreis führt zu den relevanten Archiven. Der obere Kreis zeigt die Betriebssystemauswahl an. Werden Sie hier nicht fündig, hilft der Link Other Downloads (rechter Kreis) weiter.

1.2 Das richtige Eclipse-Archiv finden 5 Ist es nicht gelungen, eine kompatible Version zu finden, dann gelangen Sie über den Link Other builds auf eine Webseite, die unter der Adresse Eclipse 4.5 ohne CDT herunterladen http://download.eclipse.org/eclipse/downloads/. zu erreichen ist. Auf ihr befindet sich eine Liste, die zahlreiche weitere Pakete enthält, darunter auch die neusten Meilensteine und die aktuellen Nightly Builds. Die letzte offizielle Veröffentlichung finden Sie immer unter Latest Release. Für dieses Buch stellt Version 4.5.0 die Grundlage dar. Folgen Sie einem dieser Links, erhalten Sie eine Seite, die mehrere Listen enthält, wovon Sie die Liste Eclipse SDK in Abbildung 1-2 sehen können. Darin werden alle von Eclipse unterstützten Architekturen aufgeführt, von denen Sie sich eine passende aussuchen. So existiert das Produkt unter Linux für x86, x86 für 64 Bit, für den PowerPC oder für IBMs s390/s390x-plattformen. Für das Windows-Betriebssystem wird sowohl eine 32-Bit- als auch eine 64-Bit-Variante für Intel-Prozessoren angeboten. Versionen für andere Betriebssysteme wie OS X oder Solaris 10 sind hierüber ebenso in diversen Ausführungen verfügbar. Eine Eclipse-Version, zu der auch gleich CDT geliefert wird, finden Sie in diesen Listen jedoch nicht. Sie sollten deshalb auf jeden Fall Abschnitt 1.7.1 nicht vergessen, da dort beschrieben wird, wie CDT zu einer bestehenden Eclipse-Installation hinzugefügt wird. Welches der aufgeführten Pakete ist aber das richtige? Wenn Sie auch für Java entwickeln möchten, dann bietet sich das Eclipse SDK an. Andernfalls können Sie auch mit dem Archiv Platform Runtime Binary vorliebnehmen, das allerdings z. B. auch keine Unterstützung von Versionsverwaltungssystemen wie Git mit sich bringt. Selbstverständlich können Sie auch diese bei Bedarf problemlos nachinstallieren.

6 1 Installation Abb. 1-2 Auszug der Liste der von Eclipse unterstützten Plattformen vom Juli 2015 1.3 Installation unter Linux Distribution oder Download? Download Um Eclipse und CDT unter Linux zu installieren, existieren im Wesentlichen zwei Möglichkeiten. Zum einen bieten zahlreiche Distributionen Pakete für Hauptprogramm und CDT-Plugin an, zum andern lässt sich Eclipse über die Downloadseite von http://www.eclipse.org herunterladen, so wie in Abschnitt 1.2 beschrieben. Durch die automatische Auflösung von Paketabhängigkeiten stellt der erste Weg sicher, dass alle von Eclipse geforderten Softwarevoraussetzungen erfüllt sind. Dagegen ist bei der zweiten Variante der Benutzer dafür verantwortlich, dass eine kompatible Java-Runtime sowie die freie Komponentenbibliothek GTK+, auf die das Benutzerinterface der in diesem Buch verwendeten Eclipse-Version unter Linux aufsetzt, installiert sind. Trotz der automatischen Abhängigkeitsauflösung, die lange Suchund-finde-Spiele vermeiden würde, empfehle ich Ihnen, die Installation ohne ein Paketverwaltungssystem durchzuführen. Diese Vorgehensweise hat den Vorteil, den Zugriff auf die aktuelle Eclipse-Version zu ermöglichen, denn oft sind die Paket-Maintainer verglichen mit der Eclipse-Entwicklung weit im Rückstand. Insbesondere finden sich die relativ häufig herausgegebenen Meilensteine kaum in den Archiven. Zudem können Sie auf diese Weise problemlos mehrere Versionen von

1.3 Installation unter Linux 7 Eclipse installieren, um beispielsweise den neusten Meilenstein zu testen. 1.3.1 Compiler und Tools Die Installation von Compiler, Debugger und Make sollte unter Linux kein Problem darstellen. Häufig gehören die wichtigsten Entwicklerwerkzeuge in der Standardinstallation dazu oder können zumindest leicht zum System hinzugefügt werden. Überprüfen Sie, ob die Software vorhanden ist, indem Sie z. B. im Terminal gcc --version und make --version eingeben. Sollte dies nicht der Fall sein, installieren Sie die notwendigen Pakete, was Sie bei Debian-Linux mit dem Kommando aptitude install gcc gdb make als Benutzer root bewerkstelligen. 1.3.2 Java Damit Sie unter Linux Java-Applikationen wie Eclipse ausführen können, muss Ihr System eine Java-Laufzeitumgebung bereitstellen. Eclipse ist sowohl mit den Laufzeitumgebungen der von Oracle aufgekauften Firma Sun, dem Äquivalent von IBM als auch mit BEA JRockit als lauffähig getestet worden. Hingegen überprüft die Eclipse Foundation die Plattform nicht mit dem Java-Compiler der GNU Compiler Collection GCJ, so dass bei dessen Einsatz Probleme auftreten können. Empfehlen würde ich Ihnen jedoch, tatsächlich die von Sun abstammende und als HotSpot bekannte Laufzeitumgebung zu benutzen, da die Installation recht einfach gelingt. Die Installation der von Oracle verwalteten Java-Runtime kann entweder direkt über das von http://www.java.com/de/ heruntergeladene Archiv oder über eine Methode erfolgen, die von Ihrer Linux- Distribution angeboten wird. Obwohl sich eine aktuelle Java-Version auch ohne Root-Zugriff installieren lässt, lege ich Ihnen die letztere Methode nahe, da sie distributionspezifische Feinheiten beachtet. Wenn die Java-Laufzeitumgebung in der Version 7 installiert werden soll, wie sie von Eclipse 4.5 und CDT 8.7 vorausgesetzt wird, erledigen Sie dies unter einem aktuellen Debian-Linux z. B., indem Sie

8 1 Installation aptitude install openjdk-7-jre als Root in einer Shell ausführen. Falls Sie ausschließlich C- oder C++- Programme mit Eclipse entwickeln möchten und für das ganze Themenspektrum, das dieses Buch abdeckt, genügt eine Runtime ohne Java- Entwicklerunterstützung allemal. 1.3.3 Eclipse Um Eclipse auf Linux zu installieren, ist es ausreichend, das heruntergeladene Archiv in einem Verzeichnis Ihrer Wahl (z. B. Ihrem Home- Verzeichnis) zu entpacken. Dort kann Eclipse per Eingabe von ~/eclipse/eclipse in einer Kommandozeile gestartet werden. 1.4 Installation unter Windows Standardmäßig kein eigener C- oder C++-Compiler auf Windows-Systemen Da Windows weder einen C- noch einen C++-Compiler mit sich bringt, ist der Aufwand der manuellen Installation etwas größer als unter Linux. Möchten Sie die GNU Compiler Collection verwenden, haben Sie zwischen zwei verschiedenen Paketen die Auswahl, nämlich Cygwin und MinGW, die sich in ihrer Philosophie leicht unterscheiden. In Unterabschnitt 1.4.1 beleuchten wir diese beiden Varianten etwas näher und erläutern, wie sie auf dem Rechner eingerichtet werden können. Anschließend wird kurz auf die Bereitstellung von Java unter Windows eingegangen, um sich danach der Installation von Eclipse selbst zuzuwenden. 1.4.1 Compiler und Tools Cygwin MinGW Die erste Variante, den Compiler des GNU-Projektes auf Windows zu verwenden, wird durch das Cygwin-Projekt ermöglicht. Cygwin zielt auf eine möglichst einfache Portierung von POSIX-kompatibler Software auf das Windows-Betriebssystem ab. Es ist dabei als dynamische Bibliothek entworfen, die viele Teile der POSIX-API transparent auf die Windows-API abbildet. Neben einer Fülle von Entwickler-Tools existiert eine breite Palette von Software, die auf diese Weise auf Windows lauffähig gemacht worden ist. Als komplexer Vertreter solcher Software sei ein kompletter X-Server genannt. Die zweite Option bietet das MinGW-Projekt. Dabei steht die Abkürzung MinGW für»minimalist GNU for Windows«. Die Entwickler verfolgen eine möglichst umfassende Unterstützung zum Kompilieren