Plattformunabhängig und OpenSource programmieren

[tobb]

Hi,

ich möchte von nun an plattformunabhängig und OpenSource programmieren.
Dabei muss man (so ist mein Wissenstand bis jetzt) auf zwei Dinge beachten:
1. Den Code so gestallten, dass er systemunabhängig ist (d.h. systemunabhängige Bibliotheken verwenden)
2. Den Code so anbieten, dass er von jedem eingesehen und auch sofort kompilliert werden kann.

Punkt 1 ist einfach zu erledigen. Punkt 2 nicht.
Da ich bis jetzt immer mit IDEs programmiert habe, waren spezielle Einstellungen wie Bibliotheksabhängigkeiten (also sprich: die Linkliste für gcc) immmer in einer speziellen Datei der IDE gespeichert. Wenn ich aber nun OpenSource coden will, kann ich ja nicht eine spezielle IDE vorrausetzen.
Muss ich das mit makefiles lösen?
Selbst dann muss ich ja immernoch den gcc vorraussetzen... obwohl das eigentlich alle OpenSource Programme machen... ich kenne jedenfalls keinen der sein Zeug mit MS VC++ kompilliert...

Habt ihr Tipps wie ich Punkt 2 realisieren kann bzw wie die gängige Praxis ist?

[gms]

Du mußt das nicht mit makefiles lösen, mit automake kannst du die Makefiles generieren, mit autoconf kannst du ein portables ./configure Script erstellen, welches auf den gängigen Plattformen lauffähig ist ( mittels mingw+msys oder cygwin sogar unter Windows )

Hier habe ich für dich eine kurze Einführung gefunden:
http://developers.sun.com/solaris/articles/gnu.html

Gruß
gms

[armin]

Wobei ich heutzutage dringend zu CMake raten würde, wenn man Automake nicht sowieso schon kann. Den support für VC gibt es dann gratis
http://www.cmake.org/HTML/Documentation.html sollte einen kurzen Überblick geben können.

[tobb]

Und warum CMake und nicht automake "heutzutage"?
Meinst du mit VC Visual C++?

[armin]

Aus meiner Sicht lohnt es sich alleine schon, da es viel einfacher zu erlenernen ist. Desweiteren läuft es nativ unter Linux, MacOS und Windows.
Hier mal ein Artikel, warum für KDE4 Cmake genutzt wird: http://dot.kde.org/1172083974/
Ja, meinte mit VC Visual C++.

[BeS]

falls du mit Qt arbeitest, könnte evtl. qmake auch eine Möglichkeit sein.

[gms]

cmake verwende ich auch sehr gerne, hauptsächlich für Projekte, an denen ich auch unter Windows coden muß.
Die GNU-Tools sind aber immer noch zu empfehlen, wenn eine möglichst breite Unterstützung auf den Unix-Plattformen angestrebt wird. Wenn Windows als Binary-Distribution eingeplant wird, dann ist es auch kein Problem, daß diese Projekte dann unter Windows etwas schwieriger zu bauen sind.
Ein mit den GNU-Tools sauber erstelltes Projekt unterstützt z.B "von Haus aus", die Standardverzeichnisse wie sie auf den Unix-Plattformen Verwendung finden ( bin, sbin, lib, libexec, etc, var, share...), cmake kennt "nur eine dem "./configure --prefix=..." vergleichbare Installation.
Der Support für die hauseigenen Compiler auf den diversen Unix-Plattformen, ist bei den GNU-Tools auch besser und Cross-Compiling wird von cmake derzeit überhaupt noch nicht unterstützt.

Gruß
gms

[tobb]

Hi,

kennt jemand ein etwas ausführlichesres Tutorial zu diesem Thema (cmake).
Ich habe das gelesen:
http://www.linuxjournal.com/article/6700

Aber das ist nicht gerade sehr einsteigerfreundlich...
Im Tut steht zum Beispiel so etwas:

Code: Alles auswählen

ADD_LIBRARY(MyLibrary STATIC libSource.c)
ADD_EXECUTABLE(MyProgram main.c)

und ich frage mich, warum man es nicht einfahc so macht:

Code: Alles auswählen

ADD_EXECUTABLE(MyProgram main.c libSource.c)

Aber solche fragen bleiben offen...
Was ist überhaupt mit LIBRARY gemeint? Was kann alles eine LIBRARY sein? Nur *.c files? Oder auch DLLs? Keine Ahnung...

Wie habt ihr das Zeug gelernt...

[gms]

Unter dem Begriff Library wird unter Windows eine statische Library (*.lib) oder eine DLL (*.dll) und auf den Unix-Systemen eine statische Library (*.a) bzw eine Shared Library ( meistens *.so, seltener *.a, wird auch Shared Object genannt ) verstanden.

In deinem Beispiel sind "MyLibrary" und "MyProgram" zwei unabhängige Teile eines Projekts.
Für die statische Library "MyLibrary" muß zuerst die Objektdatei LibSource ( *.o auf den meisten Unix-Systemen, *.obj unter Windows ) durch Kompilieren von LibSource.c erzeugt werden, danach wird "lib" unter Windows bzw "ar" unter Linux aufgerufen und eine statische Library erzeugt.
Das Programm "MyProgram" hat in deinem ersten Beispiel nur eine Abhängigkeit zu "main.c". Daher wird die Objektdatei "main.o(bj)" erzugt und vom jeweiligen Linker, zusammen mit den Runtime-Libraries, zu einem Programm "MyProgram" zusammengelinkt.

Willst du jetzt auch noch die Library "MyLibrary" zu dem Programm "MyProgram" dazulinken, dann kannst du noch
TARGET_LINK_LIBRARIES(MyProgram MyLibrary)
angeben

und ich frage mich, warum man es nicht einfahc so macht: Code:

ADD_EXECUTABLE(MyProgram main.c libSource.c)

das ist natürlich eine Lösungsmöglichkeit, die Entscheidung ob "LibSource" in eine Library ausgelagert werden soll, oder nicht, bleibt dir überlassen. Bei diesem einfachen Beispiel wird deine Lösungsmöglichkeit wahrscheinlich auch besser sein. Ab einer gewissen Größe deines Projekts, wirst du es aber von selber untergliedern wollen. Der Speicher in dem der Code einer Shared Library liegt, kann auch von mehreren Programmen gleichzeitig verwendet werden, was natürlich auch von Vorteil sein kann.

Wie habt ihr das Zeug gelernt...

das sind alles Dinge, die du nur mittels "Learning by Doing" wirklich lernen kannst
Ein Tutorial habe ich für cmake nicht gebraucht. Ein Beispiel habe ich mir angeschaut, danach habe ich ein kleineres Projekt von mir umgestellt und immer wenn ich eine Funktionalität benötigt habe, welche ich noch nicht gekannt habe, habe ich hier http://www.cmake.org/HTML/Documentation.html nachgeschlagen.


Gruß
gms

[tobb]

Ok, ich hab' jetzt enfach mal eine main.cpp geschrieben und mit

Code: Alles auswählen

g++ -s -O2 -o test.exe main.cpp

kompilliert. test.exe ist nun 294 KB groß. (Bin grad unter Windows...)

Nun wollte ich das ganze mit CMake ausprobieren.
Hab' also folgende CMakeLists.txt geschrieben (ganz banal):

Code: Alles auswählen

PROJECT(test)
ADD_EXECUTABLE(test main.cpp)

und dann das CMake GUI geladen und den Ordner der Sourcedateien und Binarydateien angegegeben. Nach einem klick auf Configure musste ich noch den Compiler auswählen (MinGW) und hab' dann auf OK geklickt...
CMake hat mir dann ein Makefile erstellt...
Wenn ich jetzt allerdings einfach ein make anwende wird mir zwar eine funktionierende Anwendung kompilliert, allerdigns ist sie über 500KB groß... wahrscheinlich mit DEBUG Infos usw... klar ich hab' das ja auch nirgendwo angegeben, dass ich das nicht will.

Jetzt die Frage:
Bei g++ habe ich die Optionen -O2 und -s angegeben. Wie bringe ich das CMake bei?

CMake generiertes Makefile:

Code: Alles auswählen

default_target: all
.SUFFIXES:
.SUFFIXES: .hpux_make_needs_suffix_list
$(VERBOSE).SILENT:
cmake_force:
SHELL = cmd.exe
CMAKE_COMMAND = "Z:\Eigene Dateien\Programme\CMake 2.4\bin\cmake.exe"
RM = "Z:\Eigene Dateien\Programme\CMake 2.4\bin\cmake.exe" -E remove -f
CMAKE_EDIT_COMMAND = Z:\EIGENE~1\PROGRA~1\CMAKE2~1.4\bin\CMAKES~1.EXE
CMAKE_SOURCE_DIR = "Z:\Eigene Dateien\tobi - home\Programmieren\Eb"
CMAKE_BINARY_DIR = "Z:\Eigene Dateien\tobi - home\Programmieren\Eb\bin"
include CMakeFiles/progress.make
edit_cache:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
	"Z:\Eigene Dateien\Programme\CMake 2.4\bin\CMakeSetup.exe" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
edit_cache/fast: edit_cache
rebuild_cache:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
	"Z:\Eigene Dateien\Programme\CMake 2.4\bin\cmake.exe" -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
rebuild_cache/fast: rebuild_cache
all: cmake_check_build_system
	$(CMAKE_COMMAND) -E cmake_progress_start "Z:\Eigene Dateien\tobi - home\Programmieren\Eb\bin\CMakeFiles" $(CMAKE_ALL_PROGRESS)
	$(MAKE) -f CMakeFiles/Makefile2 all
	$(CMAKE_COMMAND) -E cmake_progress_start "Z:\Eigene Dateien\tobi - home\Programmieren\Eb\bin\CMakeFiles" 0
clean:
	$(MAKE) -f CMakeFiles/Makefile2 clean
clean/fast: clean
preinstall: all
	$(MAKE) -f CMakeFiles/Makefile2 preinstall
preinstall/fast:
	$(MAKE) -f CMakeFiles/Makefile2 preinstall
depend:
	$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 1
Eb.exe: cmake_check_build_system
	$(MAKE) -f CMakeFiles/Makefile2 Eb.exe
Eb.exe/fast:
	$(MAKE) -f CMakeFiles/Eb.exe.dir/build.make CMakeFiles/Eb.exe.dir/build
main.obj:
	$(MAKE) -f CMakeFiles/Eb.exe.dir/build.make CMakeFiles/Eb.exe.dir/main.obj
main.i:
	$(MAKE) -f CMakeFiles/Eb.exe.dir/build.make CMakeFiles/Eb.exe.dir/main.i
main.s:
	$(MAKE) -f CMakeFiles/Eb.exe.dir/build.make CMakeFiles/Eb.exe.dir/main.s
help::
	@$(CMAKE_COMMAND) -E echo "The following are some of the valid targets for this Makefile:"
	@$(CMAKE_COMMAND) -E echo "... all (the default if no target is provided)"
	@$(CMAKE_COMMAND) -E echo "... clean"
	@$(CMAKE_COMMAND) -E echo "... depend"
	@$(CMAKE_COMMAND) -E echo "... Eb.exe"
	@$(CMAKE_COMMAND) -E echo "... edit_cache"
	@$(CMAKE_COMMAND) -E echo "... rebuild_cache"
	@$(CMAKE_COMMAND) -E echo "... main.obj"
	@$(CMAKE_COMMAND) -E echo "... main.i"
	@$(CMAKE_COMMAND) -E echo "... main.s"
cmake_check_build_system:
	$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 0

[gms]

Jetzt die Frage:
Bei g++ habe ich die Optionen -O2 und -s angegeben. Wie bringe ich das CMake bei?

verstehe die Frage nicht:? Wenn du es geschafft hast, im CMake GUI den Compiler zu setzen, dann wirst du es doch auch schaffen dort die CXX_FLAGS zu setzen, oder geht das dort nicht
z.B.: CMAKE_CXX_FLAGS_RELEASE auf " -O2 -s " und CMAKE_BUILD_TYPE auf "RELEASE" setzen

[armin]

Ein Beispiel aus einem Projekt von mir:

Code: Alles auswählen

# set default build type
IF (NOT CMAKE_BUILD_TYPE)
  SET(CMAKE_BUILD_TYPE Release)
ENDIF (NOT CMAKE_BUILD_TYPE)

IF (CMAKE_COMPILER_IS_GNUCXX)
  # -Wno-long-long: Qt code doesn't compile without
  # -Wno-unknown-pragmas:  disable warnings about unknown pragmas used for Msvc
  # -Wno-variadic-macros: we use variadic macros for logging, disable the warning
  # -Wno-reorder: otherwise we get warnings if a contructor initializes members in another order than defined in the header
  # -Wno-unused-parameter: otherwise we don't see the important warnings because of all the unused parameters
  SET(CMAKE_CXX_FLAGS "-fmessage-length=0 -Wall -Wextra -Wno-long-long -Wno-unknown-pragmas -Wno-variadic-macros -fdiagnostics-show-option -Wno-reorder -Wno-unused-parameter")
  # Release build
  SET(CMAKE_CXX_FLAGS_RELEASE "-O2")
  # Debug Build
  SET(CMAKE_CXX_FLAGS_DEBUG "-g")
ENDIF (CMAKE_COMPILER_IS_GNUCXX)