MinGW64 auch einfacher

Nach längerem bemühen mit dem MinGW64 hab ich jetzt noch eine einfache Möglichkeit gefunden den MinGW64 zu installieren. Unter http://tdm-gcc.tdragon.net/ findet man den Installer. Es gibt verschiedene Versionen, einen für 32-Bit-Version komplett, einen für 64-Bit Version komplett und einen Webinstaller, bei dem man genau angibt was man installiert haben möchte und nur der Teil geladen wird.

Dieser zum einem aktueller als der MinGW64 (Hat aktuelle die Version 4.5.1) und kann auch Programme als 64-Bit-Version erzeugen. Und natürlich ist es viel einfacher als sich die Versionen alles selbst zusammen zu suchen und sie auszupacken. Dagegen gibt es nur einen Nachteil, das der von TDM etwas älter ist, was mir persönlich nicht wirklich stört.

Daher werde ich jetzt wohl komplett auf TDM umsteigen.

CodeBlocks MinGW Linker Einstellungen (Programme ohne MinGW Laufzeit-Dlls)

Da ich mir des öfteren auch schon die Frage gestellt habe, wieso ich immer diverse Laufzeit-Dlls bei meinen durch MinGW übersetzten Programmen mitgeben muss und ich es erst heute wieder in einem Kommentar aufkam, hab ich mir die Mühe gemacht und danach gesucht. Natürlich wurde ich auch fündig und es auch gar nicht so schwer, nachdem man Verstanden hat wo man die Parameter einstellen muss.

Die Rätselhaften Parameter sind folgende:

-static-libgcc -static-libstdc++

Das war der erste Teil. Der zweite Teil war dann noch wo gebe ich diese Flags bei CodeBlocks an. Und wer lesen kann ist klar im Vorteil, man muss diese beim Linker und _NICHT_ beim Compiler angeben. Also Rechtsklick aufs Projekt und zu den „Build options…“. In der Tablasche „Linker settings“ findet man den Frame „Other linker options:“ und dort trägt man beide Parameter ein. Sieht dann ungefähr so aus:CodeBlocks Linker EinstellungenWie man hier noch sieht, gibt stehen 2 weitere Parameter drin, um die folgende Warnmeldung die ich seit neuestem sehen zu deaktivieren:

warning: auto-importing has been activated without –enable-auto-import specified on the command line.

Sollte ich noch weitere wichtige Parameter vergessen habe einfach einen Kommentar hinterlassen oder per Mail zukommen dann werden Sie hier mit aufgenommen.

Boost mit MinGW64

Zuerst brauchen wir eine Lauffähige MinGW64 Umgebung. Eine Installationsleitung findet man dazu hier.

Nachdem man MinGW64 besitzt sollte man sich noch die Quellen von boost holen, am einfachsten von Ihrer Website http://www.boost.org/users/download/ laden. Es wird eigentlich nur die boost-Quellen selbst benötigt, da in diesem auch immer die Quellen von bjam dabei sind. Und hier findet man noch eine Installation zu Perl, wovon boost nicht abhängig ist, aber wenn man Sie installieren möchte dann vor dem übersetzten.

Nun müssen die Quellen noch entpackt werden. Und dann stellen wir uns in den entpackten Ordner mit der Eingabeaufforderung.

Mit dem Nachfolgenden Befehl wird die Pfad Variable so gesetzt das ein direkter Aufruf der Komponenten möglich ist, wobei der Pfad entsprechend angepasst werden muss:

SET PATH=C:\Programme\MinGW64\bin;%PATH%

Nun erstellen wir uns bjam mit folgendem Aufruf direkt im boost-src Ordner:

bootstrap.bat  ‚ Damit hat er bei mir immer den MS Compiler benutzt
oder: tools\jam\src\build.bat [COMPILER] (zB msvc, gcc, ….)

Da bei mir der Aufruf von build.bat mit mingw oder gcc nicht funktioniert hat, hab ich denn die Datei „x86_64-w64-mingw32-gcc.exe“ im bin-Verzeichnis in „gcc.exe“ umbenannt und dann build.bat nochmals mit gcc aufgerufen und schon ging es! Dafür musste ich dann die bjam.exe per Hand aus dem „bin.ntx86_64“-Ordner in die Root des boost-Ordners kopieren.

Und nun wird boost erstellt. Dies wird mit folgenden Befehlen durchgeführt, einer für die statischen Libs und einer für dynamischen Libs:

bjam –prefix=<PfadErstellteDateien> –without-mpi –without-python toolset=gcc address-model=64 variant=release link=static threading=multi install
bjam –prefix=<PfadErstellteDateien> –without-mpi –without-python toolset=gcc address-model=64 variant=release link=static threading=multi install

Die „–without..“-Parameter werden nicht unbedingt gebraucht, so sieht man aber keine Meldungen darüber. Nun müssen entweder die Dateien noch ins MinGW Verzeichnis kopiert werden oder in der IDE die Pfade passend gesetzt werden.

Da ich mir die ganzen Kommandos nicht immer einzeln tippen wollte bei jeder neuen Version hab ich mir ein kleines Batch-File geschrieben, welches eine Ebene höher als die Root der Quellen von boost abgelegt ist. In diesem werden am Anfang alle Pfade gesetzt und die Datei nur noch ausgeführt werden. So muss auch bei jeder neuen Version nur die Pfadangabe angepasst werden und die Datei nochmal ausführen damit mit der aktuellen Version gearbeitet werden kann. Hab die Datei aber immer aus der Eingabeaufforderung gestartet, durch Doppeltklick ging irgendwie immer was schief. Hier die Datei: boost_install.cmd (Das .txt muss durch .bat oder .cmd ersetzt werden, Download am einfachsten über Punkt „Verlinkten Inhalt speichern unter…“ im Kontextmenü)

MinGW64 unter Windows mit Code::Blocks

Zuerst müssen Sie sich die benötigten Paket herunterladen, die unter dieser URL zu finden sind:

http://sourceforge.net/projects/mingw-w64/files/

Aber aufpassen das Sie die Packete im Unterordner „Toolchains targetting Win64“ laden. Unterhalb von Release werden Sie nichts finden, sie müssen zu den „Automated Builds“ gehen und dort einfach das aktuellste Packet nehmen das vom Namen her so aufgebaut sein muss:

mingw-w64-bin_i686-mingw_<Datum>.zip

Dieses Packet einfach an den von Ihnen gewünschten Ort entpacken, zB „C:\Programme\MinGW64\“. Ich habe mir aber noch zusätzlich diese Packet kopiert:

libiconv-1.13.1-win64-20100604.zip
make-3.81-20100428.zip
pthreads-20100604.zip
i686-w64-mingw32-gdb-7.1.50-20100528.zip (Zum Debuggen)

Dies müssen dann entsprechend noch mit in den Ordner kopiert werden. Aber Vorsicht bei manchen nicht einfach die Root entpacken sonder in die entsprechenden Unterordner gehen bis der Aufbau dem vom mingw selbst entspricht. Also ein bin-, include- und weitere Ordner müssen vorhanden sein. (Bei pthreads müssen Sie erst in den mingw64-Ordner)

Sollte nun alles entpackt sein starten sie Code::Blocks und aktivieren Sie das Compiler-Fenster unter „Settings->Compiler und debugger…“. Kopieren Sie den Eintrag „GNU GCC Compiler“ und geben Sie Ihr einen neuen Namen zB „GNU GCC 64 Compiler“. In der „Tablasche Toolchain executables“ geben Sie den Pfad zu ihrem MinGW64 an (In unserem Beispiel oben wäre es der Pfad „C:\Programme\MinGW64\“).

Bei „Program Files“ müssen Sie bei den  Programmen die Namen noch anpassen, folgende müssen angepasst werden:

C compiler: x86_64-w64-mingw32-gcc.exe
C++ compiler: x86_64-w64-mingw32-g++.exe
Linker for dynamic libs: x86_64-w64-mingw32-g++.exe
Linker for static libs: x86_64-w64-mingw32-ar.exe
Debugger: gdb.exe (bleibt gleich)
Ressource compiler: x86_64-w64-mingw32-windres.exe
Make program: mingw32-make.exe

Bei „Additional Paths“ geben Sie noch folgenden Ordner an:

<PfadMinGW64>\libexec\gcc\x86_64-w64-mingw32\<VERSION>\

Bei  „Search directories“ müssen Sie auch noch die Pfade eingetragen werden. Beim Compiler diese:

<PfadMinGW64>\include
<PfadMinGW64>\x86_64-w64-mingw32\include
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>\backward
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>\x86_64-w64-mingw32
<PfadMinGW64>\lib\gcc\x86_64-w64-mingw32\<VERSION>\include

Und bei Linker noch folgende:

<PfadMinGW64>\lib
<PfadMinGW64>\x86_64-w64-mingw32\lib

Und nun bei Ihrem Projekt den neuen Compiler angeben, durch ein Rechtsklick aufs Projekt dann „Build Options…“ auswählen. Nun bei „Selected compiler“ den neuen Compiler auswählen, aber Vorsicht er wird für das „Build target“ definiert welches im linken Baum ausgewählt ist. Um es noch im 64Bit Modus zu kompilieren müssen Sie unter „Compiler settings“->“Other options“ noch ein „-m64“ angeben. Alles mit OK bestätigen und über „Build“->“Rebuild“ (Ctrl + F11) alles neu erstellen lassen, im Dialog noch mit ja bestätigen.

Hier noch einen Link bei dem man auch den Compiler und weitere Biliotheken laden kann: http://www.dragon.org/mingw/

libxml mit MinGW übersetzten

Zuerst benötigen wir noch ein paar andere Bilbiotheken dafür, alle sind direkt hier (ftp://ftp.zlatkovic.com/libxml) zu finden, oder nachfolgend entsprechend die Quellen zum selber übersetzen. Wobei ich in diesen fällen für die Libraries selbst bin, auch häufig auf den unten genannten Websiten auch noch zu finden.

libiconv: Als Sourcen auf der Website Linux bzw. Windows zu finden oder direkt diesen Link benutzen: Linux oder Windows.

libzlib: Als Sourcen auf der Website http://www.zlib.net/.

Jetzt müssen wir uns mal die aktuellen Source herunterladen, am einfachsten auf dieser Website http://xmlsoft.org/downloads.html unter Snapshot diesen Link benutzen: libxml2-git-snapshot.tar.gz.

Nach dem entpacken wechseln wir in den entsprechenden Ordner:

libxml-source\win32

Dort konfigurieren wir dann unser makefile mit diesem Befehl:

cscript configure.js compiler=mingw prefix=%OUTPUT-DIR% include=%MINGW-INCLUDE% lib=%MINGW-LIB% debug=yes iso8859x=yes

Hier nochmal ein Beispiel, damit kann sich meist mehr vorstellen, so werden sie auch direkt in den MinGW-Ordner kopiert:

cscript configure.js compiler=mingw prefix=D:\Programme\MinGW include=D:\Programme\MinGW\include lib=D:\Programme\MinGW\lib debug=yes iso8859x=yes

und nun noch installieren und in den output-Ordner kopieren lassen:

mingw32-make -f Makefile.mingw
mingw32-make -f Makefile.mingw install

Es gibt noch Probleme beim verwenden der lib, und zwar ist in der <libxml/xmlexport.h>nur bei der Sektion für _WIN32 && __MINGW32__ ist der dllexport anders gebaut und zwar steht da folgender Codefragment:

#if !defined(LIBXML_STATIC)

Bei allen anderen steht dies dabei:

#if defined(IN_LIBXML) && !defined(LIBXML_STATIC)

Wenn man diese Zeile wie bei den anderen ändert, dann funktioniert auch alles wieder oder man definiert vor den includes der libxml die LIBXML_STATIC wenn man die Library direkt mit reinkompilieren möchte.

wxWidget übersetzten mit MinGW

Zuerst einmal müssen wir ins richtige Verzeichnis wechseln, und zwar nach:

…\wxWidget\build\msw

Mit diesem Befehl räumen wir erstmal das Verzeichnis auf:

mingw32-make -f makefile.gcc clean

Und mit diesem Befehl übersetzen wir nun die wxWidget Bibliothek:
(Es wird 2 mal übersetzt, damit wir bei CodeBlocks den Debug und den Release Modus für die Projekte benutzten können)

mingw32-make -f makefile.gcc USE_XRC=1 SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1
mingw32-make -f makefile.gcc USE_XRC=1 SHARED=1 MONOLITHIC=1 BUILD=release UNICODE=1

Danach erscheinen die Librarys in Verzeichnis lib\gcc_lib und die Header im Verzeichniss include. Dies könnte man jetzt noch ins MinGW-Verzeichnis kopieren oder man lässt sie liegen und stellt die Include-Verzeichnisse entsprechend auf den Ordner ein. Unter CodeBlocks kann man dies entsprechend unter den Variablen machen.

Bei der Verwendung von CodeBlocks zum erstellen eines wxWidget-Projekts müssen die Hacken nur ensprechend so gesetzt werden wie man Sie beim MAKE-Befehl mit angegeben hat (siehe oben).

Links:  http://www.pronix.de/pronix-1138.html

——————————————————————

Nachtrag, da ich jedesmal wieder über die Namen im Build stossen und nicht weiß was sie bedeuten:

BUILD

Definiert ob eine Debug-Version oder eine Release-Version erstellt wird.

  • Eine Debug-Version erstellt die Libs mit einen „d“-Suffix — als Beispiel: „libwxmsw28d.a“/“wxmsw28d_gcc_custom.dll“
  • Eine Debug-Version erstellt die Ordner mswd bzw. mswud im wxWidget Library-Ordner
  • Eine Release-Version erstellt die Libs ohne den „d“-Suffix — als Beispiel: „libwxmsw28.a“/“wxmsw28_gcc_custom.dll“
  • Eine Release-Version erstellt die Ordner msw bzw. mswu im wxWidget Library-Ordner

SHARED

Definiert ob eine DLL (SHARED=1) oder eine Statische (SHARED=0) Version von wxWidget erstellt wird.

  • Eine DLL-Version von wxWidget erstllelt zu importierende Libs (wie libwxmsw28.a) und DLLs (so wie wxmsw28_gcc_custom.dll). Hier musst du die DLL mit deinem Programm verteilen.
  • Eine statische-Version von wxWidget erstellt nur statische Libs (so wie libwxmsw28.a), und es muss keine weitere DLL mit verteilt werden.

MONOLITHIC

MONOLITHIC steuert ob nur eine lib für alle Komponenten erstellt wird oder einzelne.

  • Ein Monolithic-Build erstellt eine einzelne zu importierente Library (so wie libwxmsw28.a) und eine einzelne DLL (so wie wxmsw28_gcc_custom.dll)
  • Ein Multilib-Build erstellt mehrere zu importierende Library (libwxexpat.a, libwxjpeg.a, etc.) Diese werden aber normalerweise für einen DLL-Build nicht benötigt, aber für einen Statischen-Build.

UNICODE

UNICODE gibt an ob die Library mit Unicode-Zeichen oder mit ANSI-Zeichen übersetzt wird.

  • UNICODE=1 erstellt die Libs mit einen „u“-Suffix — Beispiel: „libwxmsw28u.a“/“wxmsw28u_gcc_custom.dll“
  • UNICODE=0 erstellt die Libs ohne den „u“-Suffix — Beispiel: „libwxmsw28.a“/“wxmsw28_gcc_custom.dll“
Veröffentlicht unter CPP

Boost Lib mit MinGW erstellen

Nach langer Suche wurde ich endlich fuendig wie denn nun die Boost-Bibliothek zu uebersetzen ist. Hier die vorgehensweise:

  1. Zuerst muss die Bibliothek von http://www.boost.org/users/download/ geladen werden,  und in einen beliebigen Ordner entpackt werden. (zB: C:\boost\)
  2. Nun wird noch bjam benötigt welches Sie ebenso unter der Addresse die bei 1. genannt wird finden. Laden sie die Datei mit der Endung ntx86.zip, welches Sie am besten ins gleiche Verzeichniss entpacken.
  3. Erzeugen Sie einen Unterordern, in dem sich boost installieren soll. (zB: .\distrib\)
  4. In der Datei .\tools\build\v2\user-config.jam können Sie optional die Zeile:
    using mpi;
    hinzufuegen, für die Unterstüzung des MPI (Message Passing Interface) zu unterstützen.
  5. Erstellen sie nun einfacherweise im Boost-Verzeichniss eine Datei mit dem Namen boost_install.cmd und fügen den nachfolgenden Text ein:

    SET BOOSTDIST=C:\Boost\
    bjam –prefix=%BOOSTDIST% –toolset=gcc –layout=system –without-mpi –without-python –variant=release –link=dynamic –runtime-link=static stage
    bjam –prefix=%BOOSTDIST% –toolset=gcc –layout=system –without-mpi –without-python –variant=release –link=dynamic –runtime-link=static install
    xcopy %BOOSTDIST% <MinGW-Root>
    pause

    1. prefix legt das Installationsverzeichniss fest
    2. toolset legt den Compiler mit dem übersetzt werden soll fest
    3. –layout=system verhindert, dass bjam den Namen des Compilers und die Boost-Version in die Dateinamen der Binaries aufnimmt
    4. mpi und phyton werden ausgeschlossen (dies kann auch weggelassen werden)
    5. Ansonsten wird bjam aufgefordert Bibliotheken zu erzeugen, die die STL statisch hinzulinken und dynamisch zum Programm gelinkt werden
      1. stage => übersetzt alles wie gewollt ins Unterverzeichnis .\stage\
      2. install => kopiert alle wichtigen Dateien ins %BOOSTDIST% Verzeichniss das mit xcopy ins MinGW-Root-Verzeichniss kopiert wird