Toolkit

26.8.2006 19:48 | Přečteno: 1504× | Linux

Dneska jsem si trochu pohrál s configure skriptem, a chtěl jsem, aby z toho vzešlo něco, co se dá použít pro další projekty. Snažil jsem se trochu napodobit cmake:

#!/bin/sh
#
# configure script for Toolkit library
# Toolkit is distributed under the terms od BSD License
# Copyright (C) 2006 Jaroslav Šmíd <jardasmid@seznam.cz>
#

#
# Set up your project here
#

build_script()
{
	echo "Running configure script for Toolkit ..."
	
	PROJECT Toolkit
	
	toolkit_sources=(
		Toolkit/Alignment.cpp
		Toolkit/Application.cpp
		Toolkit/Archiver.cpp
		Toolkit/Box.cpp
		Toolkit/Button.cpp
		Toolkit/ButtonBox.cpp
		Toolkit/CheckButton.cpp
		Toolkit/Container.cpp
		Toolkit/Dialog.cpp
		Toolkit/Entry.cpp
		Toolkit/EventBox.cpp
		Toolkit/File.cpp
		Toolkit/FileUtils.cpp
		Toolkit/Frame.cpp
		Toolkit/HBox.cpp
		Toolkit/HPaned.cpp
		Toolkit/Image.cpp
		Toolkit/IniFile.cpp
		Toolkit/InputBox.cpp
		Toolkit/Label.cpp
		Toolkit/ListView.cpp
		Toolkit/Menu.cpp
		Toolkit/Notebook.cpp
		Toolkit/Paned.cpp
		Toolkit/ProgressBar.cpp
		Toolkit/ScrolledWindow.cpp
		Toolkit/Separator.cpp
		Toolkit/String.cpp
		Toolkit/Table.cpp
		Toolkit/Timer.cpp
		Toolkit/ToggleButton.cpp
		Toolkit/VBox.cpp
		Toolkit/Viewport.cpp
		Toolkit/VPaned.cpp
		Toolkit/Widget.cpp
		Toolkit/Window.cpp
	)
	toolkit_headers=(
		Toolkit/Alignment.h
		Toolkit/Application.h
		Toolkit/Archiver.h
		Toolkit/Array.h
		Toolkit/Bool.h
		Toolkit/Box.h
		Toolkit/Button.h
		Toolkit/ButtonBox.h
		Toolkit/Callback.h
		Toolkit/CheckButton.h
		Toolkit/Config.h
		Toolkit/Container.h
		Toolkit/Dialog.h
		Toolkit/Entry.h
		Toolkit/Enums.h
		Toolkit/EventBox.h
		Toolkit/File.h
		Toolkit/FileUtils.h
		Toolkit/Frame.h
		Toolkit/HBox.h
		Toolkit/HPaned.h
		Toolkit/Image.h
		Toolkit/IniFile.h
		Toolkit/InputBox.h
		Toolkit/Label.h
		Toolkit/ListView.h
		Toolkit/Menu.h
		Toolkit/Notebook.h
		Toolkit/Paned.h
		Toolkit/ProgressBar.h
		Toolkit/ScrolledWindow.h
		Toolkit/Separator.h
		Toolkit/String.h
		Toolkit/StringArray.h
		Toolkit/Table.h
		Toolkit/Timer.h
		Toolkit/ToggleButton.h
		Toolkit/Toolkit.h
		Toolkit/VBox.h
		Toolkit/Viewport.h
		Toolkit/VPaned.h
		Toolkit/Widget.h
		Toolkit/Window.h
	)
	ttranslator_sources=(
		ttranslator/mainwindow.cpp
		ttranslator/ttranslator.cpp
	)
	
	#
	# Let's check depencies
	#
	
	echo "Checking depencies ..."
	
	echo -en "\tpkg-config (required) ... "
	which pkg-config >/dev/null 2>&1
	if [ $? -eq 0 ]
	then
		echo "found."
	else
		echo "not found."
		echo "Depencies test failed."
		FAIL
	fi
	
	echo -en "\tgtk+-2.0 (required) ... "
	pkg-config --exists gtk+-2.0
	if [ $? -eq 0 ]
	then
		GTK2_CFLAGS="`pkg-config gtk+-2.0 --cflags 2>/dev/null`"
		GTK2_LIBS="`pkg-config gtk+-2.0 --libs 2>/dev/null`"
		echo "found."
	else
		echo "not found."
		echo "Depencies test failed."
		FAIL
	fi
	
	echo "Depencies test OK."
	
	toolkit_includes="$GTK2_CFLAGS -I."
	toolkit_libs="$GTK2_LIBS"
	toolkit_defines="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE"
	
	#
	# Let's generate Toolkit/Config.h
	#
	
	echo -n "Generating Toolkit/Config.h ... "
	
	[ -f Toolkit/Config.h ] && rm -f Toolkit/Config.h
	if [ -f Toolkit/Config.h ]
	then
		echo "failed."
		echo "ERROR: File Toolkit/Config.h exists in filesystem and could not be removed."
		FAIL
	fi
	
	cat <Toolkit/Config_prefix.h >>Toolkit/Config.h
	echo "#define TOOLKIT_INSTALL_PREFIX \"$INSTALL_PREFIX\"" >>Toolkit/Config.h
	cat <Toolkit/Config_sufix.h >>Toolkit/Config.h
	
	if [ ! -f Toolkit/Config.h ]
	then
		echo "failed."
		echo "ERROR: File Toolkit/Config.h could not be created."
		FAIL
	fi
	
	echo "done."
	
	#
	# Let's generate lib/pkgconfig/Toolkit.pc
	# pkg-config package file
	# 
	
	echo -n "Generating lib/pkgconfig/Toolkit.pc ... "
	
	[ -f lib/pkgconfig/Toolkit.pc ] && rm -f lib/pkgconfig/Toolkit.pc
	if [ -f lib/pkgconfig/Toolkit.pc ]
	then
		echo "failed."
		echo "ERROR: File lib/pkgconfig/Toolkit.pc exists in filesystem and could not be removed."
		FAIL
	fi
	
	cat <lib/pkgconfig/Toolkit.pc.template \
		| sed "s|__INSTALL_PREFIX__|${INSTALL_PREFIX}|g" \
		| sed "s|__DEFINES__|${toolkit_defines}|g" \
		>>lib/pkgconfig/Toolkit.pc
	
	
	if [ ! -f lib/pkgconfig/Toolkit.pc ]
	then
		echo "failed."
		echo "ERROR: File lib/pkgconfig/Toolkit.pc could not be created."
		FAIL
	fi
	
	echo "done."
	
	#
	# Add target
	#
	
	ADD_LIBRARY toolkit \
	            FILES ${toolkit_sources[@]} \
	            DEFINES ${toolkit_defines} \
	            INCLUDES ${toolkit_includes} \
	            LIBS ${toolkit_libs}
	            
	for I in "${toolkit_headers[@]}"
	do
		INSTALL_FILE "$I" "/include/Toolkit"
	done
	INSTALL_FILE "lib/pkgconfig/Toolkit.pc" "/lib/pkgconfig"
	
	
	
	ttranslator_includes="${toolkit_includes}"
	ttranslator_libs="toolkit ${toolkit_libs}"
	ttranslator_defines="${toolkit_defines}"
	ADD_EXECUTABLE ttranslator \
	               FILES ${ttranslator_sources[@]} \
	               DEFINES ${ttranslator_defines} \
	               INCLUDES ${ttranslator_includes} \
	               LIBS ${ttranslator_libs}
}

#
# Internal functions
# Do not modify
#

#
# Usage:
#   FAIL
#

FAIL()
{
	echo "ERROR: Configure sctipt failed."
	exit 1
}

#
# Usage:
#   PROJECT project_name [C] [CXX]
#

PROJECT()
{
	[ -n "$1" ] && PROJECT_NAME="$1"
}

#
# Usage:
#   ADD_EXECUTABLE executable_name FILES file_list INCLUDES include_list LIBS libs_list DEFINES defines_list
#

ADD_EXECUTABLE()
{
	if [ -z "$1" -o -z "$2"  ]
	then
		echo "ERROR: add_executable - bad usage"
		FAIL
	else
		TARGETS_ORDER[${TARGETS_COUNT}]="EXE"
		let TARGETS_COUNT=TARGETS_COUNT+1
	
		EXECUTABLE_FILES[${EXECUTABLE_FILES_COUNT}]="$1"
		shift
		
		ADDING=
		while [ -n "$1" ]
		do
			case "$1" in
				FILES)
					ADDING="FILES"
					;;
				DEFINES)
					ADDING="DEFINES"
					;;
				LIBS)
					ADDING="LIBS"
					;;
				INCLUDES)
					ADDING="INCLUDES"
					;;
				*)
					[ -z "$ADDING" ] && ADDING="FILES"
					case "$ADDING" in
						FILES)
							EXECUTABLE_FILES_SOURCES[${EXECUTABLE_FILES_COUNT}]="${EXECUTABLE_FILES_SOURCES[${EXECUTABLE_FILES_COUNT}]} $1"
							;;
						DEFINES)
							EXECUTABLE_FILES_DEFINES[${EXECUTABLE_FILES_COUNT}]="${EXECUTABLE_FILES_DEFINES[${EXECUTABLE_FILES_COUNT}]} $1"
							;;
						LIBS)
							EXECUTABLE_FILES_LIBS[${EXECUTABLE_FILES_COUNT}]="${EXECUTABLE_FILES_LIBS[${EXECUTABLE_FILES_COUNT}]} $1"
							;;
						INCLUDES)
							EXECUTABLE_FILES_INCLUDES[${EXECUTABLE_FILES_COUNT}]="${EXECUTABLE_FILES_INCLUDES[${EXECUTABLE_FILES_COUNT}]} $1"
							;;
						*)
							;;
					esac
					;;
			esac
			shift
		done
		unset ADDING
		
		FILES_TO_INSTALL[${FILES_TO_INSTALL_COUNT}]="output/${EXECUTABLE_FILES[${EXECUTABLE_FILES_COUNT}]}"
		FILES_TO_INSTALL_TARGETS[${FILES_TO_INSTALL_COUNT}]="/bin"
		let FILES_TO_INSTALL_COUNT=FILES_TO_INSTALL_COUNT+1
		
		let EXECUTABLE_FILES_COUNT=EXECUTABLE_FILES_COUNT+1
	fi
}

#
# Usage:
#   ADD_LIBRARY library_name FILES file_list INCLUDES include_list LIBS libs_list DEFINES defines_list
#

ADD_LIBRARY()
{
	if [ -z "$1" -o -z "$2"  ]
	then
		echo "ERROR: ADD_LIBRARY - bad usage"
		FAIL
	else
		TARGETS_ORDER[${TARGETS_COUNT}]="LIB"
		let TARGETS_COUNT=TARGETS_COUNT+1
		
		LIBRARY_FILES[${LIBRARY_FILES_COUNT}]="$1"
		shift
		
		ADDING=
		while [ -n "$1" ]
		do
			case "$1" in
				FILES)
					ADDING="FILES"
					;;
				DEFINES)
					ADDING="DEFINES"
					;;
				LIBS)
					ADDING="LIBS"
					;;
				INCLUDES)
					ADDING="INCLUDES"
					;;
				*)
					[ -z "$ADDING" ] && ADDING="FILES"
					case "$ADDING" in
						FILES)
							LIBRARY_FILES_SOURCES[${LIBRARY_FILES_COUNT}]="${LIBRARY_FILES_SOURCES[${LIBRARY_FILES_COUNT}]} $1"
							;;
						DEFINES)
							LIBRARY_FILES_DEFINES[${LIBRARY_FILES_COUNT}]="${LIBRARY_FILES_DEFINES[${LIBRARY_FILES_COUNT}]} $1"
							;;
						LIBS)
							LIBRARY_FILES_LIBS[${LIBRARY_FILES_COUNT}]="${LIBRARY_FILES_LIBS[${LIBRARY_FILES_COUNT}]} $1"
							;;
						INCLUDES)
							LIBRARY_FILES_INCLUDES[${LIBRARY_FILES_COUNT}]="${LIBRARY_FILES_INCLUDES[${LIBRARY_FILES_COUNT}]} $1"
							;;
						*)
							;;
					esac
					;;
			esac
			shift
		done
		
		FILES_TO_INSTALL[${FILES_TO_INSTALL_COUNT}]="output/lib${LIBRARY_FILES[${LIBRARY_FILES_COUNT}]}.so"
		FILES_TO_INSTALL_TARGETS[${FILES_TO_INSTALL_COUNT}]="/lib"
		let FILES_TO_INSTALL_COUNT=FILES_TO_INSTALL_COUNT+1
		
		let LIBRARY_FILES_COUNT=LIBRARY_FILES_COUNT+1
	fi
}

#
# Usage:
#  INSTALL_FILE <FILE> <DEST_DIR>
#

INSTALL_FILE()
{
	if [ -z "$1" -o -z "$2" ]
	then
		echo "ERROR: INSTALL_FILES - bad usage"
		FAIL
	else
		FILES_TO_INSTALL[${FILES_TO_INSTALL_COUNT}]="$1"
		FILES_TO_INSTALL_TARGETS[${FILES_TO_INSTALL_COUNT}]="$2"
		let FILES_TO_INSTALL_COUNT=FILES_TO_INSTALL_COUNT+1
	fi
}

#
# Internal code
# Do not modify
#

PROJECT_NAME=
TARGETS_ORDER=()
TARGETS_COUNT=0
EXECUTABLE_FILES_COUNT=0
EXECUTABLE_FILES=()
EXECUTABLE_FILES_SOURCES=()
EXECUTABLE_FILES_DEFINES=()
EXECUTABLE_FILES_LIBS=()
EXECUTABLE_FILES_INCLUDES=()
LIBRARY_FILES_COUNT=0
LIBRARY_FILES=()
LIBRARY_FILES_SOURCES=()
LIBRARY_FILES_DEFINES=()
LIBRARY_FILES_LIBS=()
LIBRARY_FILES_INCLUDES=()

FILES_TO_INSTALL_COUNT=0
FILES_TO_INSTALL=()
FILES_TO_INSTALL_TARGETS=()

INSTALL_PREFIX="/usr/local"

#
# Parse command line
#

for I in $@
do
	case $I in
		--prefix=*)
			M_PREFIX=`cut -d= -f2 <<<$I`
			[ -n "$M_PREFIX" ] && INSTALL_PREFIX="$M_PREFIX"
			;;
	esac
done

#
# Run build script
#

build_script

#
# Have mr programmer set project name?
#

if [ -z "${PROJECT_NAME}" ]
then
	echo "ERROR: Seems mr programmer forgot to set project name."
	echo "ERROR: Tell him, he can do that by calling PROJECT() function."
	FAIL
fi

#
# Have mr programmer added some targets?
#

if [ $TARGETS_COUNT -eq 0 ]
then
	echo "ERROR: Seems mr programmer forgot to add some targets."
	echo "ERROR: Tell him, he can do that by calling ADD_LIBRARY() and ADD_EXECUTABLE functions."
	FAIL
fi

#
# Generate install and uninstall script
#

echo -n "Generating install and uninstall scripts ... "

[ -f install.sh ] && rm -f install.sh
if [ -f install.sh ]
then
	echo "failed."
	echo "ERROR: File install.sh exists in filesystem and could not be removed."
	FAIL
fi

[ -f uninstall.sh ] && rm -f uninstall.sh
if [ -f uninstall.sh ]
then
	echo "failed."
	echo "ERROR: File install.sh exists in filesystem and could not be removed."
	FAIL
fi

#
# Install script
#

cat <<_EOF >>install.sh
#!/bin/sh

INSTALL_PREFIX="${INSTALL_PREFIX}"
[ -n "\${DESTDIR}" ] && INSTALL_PREFIX="\${DESTDIR}"

FAIL()
{
	echo "ERROR: Install script failed."
	exit 1
}

FILES_TO_INSTALL=(
_EOF

for I in ${FILES_TO_INSTALL[@]}
do
	echo -e "\t$I" >>install.sh
done

cat <<_EOF >>install.sh
)
_EOF

echo "FILES_TO_INSTALL_TARGETS=(" >>install.sh

for I in ${FILES_TO_INSTALL_TARGETS[@]}
do
	echo -e "\t$I" >>install.sh
done

cat <<_EOF >>install.sh
)

echo "Installing ${PROJECT_NAME} ..."
C_INDEX=0
for I in \${FILES_TO_INSTALL[@]}
do
	SOURCE="\$I"
	if [ ! -f "\${SOURCE}" ]
	then
		echo "ERROR: File \${SOURCE} doesn't exists in filesystem."
		echo "ERROR: Maybe you forgot to run make."
		FAIL
	fi
	TARGET_D="\${INSTALL_PREFIX}\${FILES_TO_INSTALL_TARGETS[\${C_INDEX}]}"
	TARGET="\${TARGET_D}/\`basename \${SOURCE}\`"
	echo "\${TARGET}"
	[ -d "\${TARGET_D}" ] || mkdir -p "\${TARGET_D}" >/dev/null 2>&1
	if [ ! -d "\${TARGET_D}" ]
	then
		echo "ERROR: Target directory for \`basename \${SOURCE}\` could not be created."
		FAIL
	fi
	[ -f "\${TARGET}" ] && rm -f "\${TARGET}" >/dev/null 2>&1
	if [ -f "\${TARGET}" ]
	then
		echo "ERROR: File \${TARGET} exists in filesystem and could not be removed."
		FAIL
	fi
	cp "\${SOURCE}" "\${TARGET}" >/dev/null 2>&1
	if [ ! -f "\${TARGET}" ]
	then
		echo "ERROR: File \${TARGET} could not be created."
		FAIL
	fi
	let C_INDEX=C_INDEX+1
done
echo "Instalation succesfull."
_EOF

#
# Uninstall script
#

cat <<_EOF >>uninstall.sh
#!/bin/sh

INSTALL_PREFIX="${INSTALL_PREFIX}"
[ -n "\${DESTDIR}" ] && INSTALL_PREFIX="\${DESTDIR}"

FAIL()
{
	echo "ERROR: Uninstall script failed."
	exit 1
}

FILES_TO_INSTALL=(
_EOF

for I in ${FILES_TO_INSTALL[@]}
do
	echo -e "\t$I" >>uninstall.sh
done

cat <<_EOF >>uninstall.sh
)
_EOF

echo "FILES_TO_INSTALL_TARGETS=(" >>uninstall.sh

for I in ${FILES_TO_INSTALL_TARGETS[@]}
do
	echo -e "\t$I" >>uninstall.sh
done

cat <<_EOF >>uninstall.sh
)

echo "Uninstalling ${PROJECT_NAME} ..."
C_INDEX=0
for I in \${FILES_TO_INSTALL[@]}
do
	SOURCE="\$I"
	TARGET_D="\${INSTALL_PREFIX}\${FILES_TO_INSTALL_TARGETS[\${C_INDEX}]}"
	TARGET="\${TARGET_D}/\`basename \${SOURCE}\`"
	echo "\${TARGET}"
	
	[ -f "\${TARGET}" ] && rm -f "\${TARGET}" >/dev/null 2>&1
	if [ -f "\${TARGET}" ]
	then
		echo "ERROR: File \${TARGET} could not be removed."
		FAIL
	fi
	let C_INDEX=C_INDEX+1
done
echo "Uninstalation succesfull."
_EOF

chmod +x install.sh
chmod +x uninstall.sh
echo "done."

#
# Generates Makefile
#

echo -n "Generating Makefile ... "

[ -f Makefile ] && rm -f Makefile >/dev/null 2>&1
if [ -f Makefile ]
then
	echo "failed."
	echo "ERROR: Makefile exists in filesystem and could not be removed."
	FAIL
fi


CURRENT_EXE_TARGET=0
CURRENT_LIB_TARGET=0

TARGETS_OUTPUT_FILES=()
CUR_TARGET_NUM=0
for I in ${TARGETS_ORDER[@]}
do
	case $I in
		EXE)
			CURRENT_BUILD_TARGET_OUTPUT="output/${EXECUTABLE_FILES[${CURRENT_EXE_TARGET}]}"
			let CURRENT_EXE_TARGET=CURRENT_EXE_TARGET+1
			;;
		LIB)
			CURRENT_BUILD_TARGET_OUTPUT="output/lib${LIBRARY_FILES[${CURRENT_LIB_TARGET}]}.so"
			let CURRENT_LIB_TARGET=CURRENT_LIB_TARGET+1
			;;
		*)
			continue
			;;
	esac
	TARGETS_OUTPUT_FILES[${CUR_TARGET_NUM}]="${CURRENT_BUILD_TARGET_OUTPUT}"
	let CUR_TARGET_NUM=CUR_TARGET_NUM+1
done

# Makefile section "all:"

cat <<_EOF >>Makefile
all: ${TARGETS_OUTPUT_FILES[@]}
	
_EOF

# 

CURRENT_EXE_TARGET=0
CURRENT_LIB_TARGET=0

CLEAN_OUTPUTS=
CLEAN_OBJS=

for I in ${TARGETS_ORDER[@]}
do
	case $I in
		EXE)
			CURRENT_BUILD_TARGET="EXE"
			CURRENT_BUILD_TARGET_NAME=${EXECUTABLE_FILES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_SOURCES=${EXECUTABLE_FILES_SOURCES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_DEFINES=${EXECUTABLE_FILES_DEFINES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_INCLUDES=${EXECUTABLE_FILES_INCLUDES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_LIBS=${EXECUTABLE_FILES_LIBS[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_OUTPUT="output/${CURRENT_BUILD_TARGET_NAME}"
			let CURRENT_EXE_TARGET=CURRENT_EXE_TARGET+1
			;;
		LIB)
			CURRENT_BUILD_TARGET="LIB"
			CURRENT_BUILD_TARGET_NAME=${LIBRARY_FILES[${CURRENT_LIB_TARGET}]}
			CURRENT_BUILD_TARGET_SOURCES=${LIBRARY_FILES_SOURCES[${CURRENT_LIB_TARGET}]}
			CURRENT_BUILD_TARGET_DEFINES=${LIBRARY_FILES_DEFINES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_INCLUDES=${LIBRARY_FILES_INCLUDES[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_LIBS=${LIBRARY_FILES_LIBS[${CURRENT_EXE_TARGET}]}
			CURRENT_BUILD_TARGET_OUTPUT="output/lib${CURRENT_BUILD_TARGET_NAME}.so"
			let CURRENT_LIB_TARGET=CURRENT_LIB_TARGET+1
			;;
		*)
			continue
			;;
	esac
	CLEAN_OUTPUTS="${CLEAN_OUTPUTS} ${CURRENT_BUILD_TARGET_OUTPUT}"
	OUTPUT_OBJS=()
	CUR_OBJ_NUM=0
	for SOURCE_FILE in ${CURRENT_BUILD_TARGET_SOURCES}
	do
		SOURCE_FILE_NAME="`basename ${SOURCE_FILE}`"
		SOURCE_FILE_NAME="`cut -d. -f1 <<<${SOURCE_FILE_NAME}`"
		SOURCE_FILE_DIR="`dirname ${SOURCE_FILE}`"
		OUTPUT_OBJ_DIR="output/objs/${SOURCE_FILE_DIR}"
		[ -d "${OUTPUT_OBJ_DIR}" ] || mkdir -p "${OUTPUT_OBJ_DIR}" >/dev/null 2>&1
		if [ ! -d "${OUTPUT_OBJ_DIR}" ]
		then
			echo "failed."
			echo "ERROR: Directory ${OUTPUT_OBJ_DIR} for object files could not be created."
			FAIL
		fi
		OUTPUT_OBJS[${CUR_OBJ_NUM}]="${OUTPUT_OBJ_DIR}/${SOURCE_FILE_NAME}.o"
		let CUR_OBJ_NUM=CUR_OBJ_NUM+1
	done
	unset CUR_OBJ_NUM
	unset SOURCE_FILE_NAME
	unset SOURCE_FILE_DIR
	unset OUTPUT_OBJ_DIR
	CLEAN_OBJS="${CLEAN_OBJS} ${OUTPUT_OBJS[@]}"
	
	DEP_LIBS=
	CURRENT_BUILD_TARGET_LIBS_NEW=
	for LIB in ${CURRENT_BUILD_TARGET_LIBS}
	do
		if [ "`cut -dl -f1 <<<$LIB`" != "-" -a "`cut -dL -f1 <<<$LIB`" != "-" ]
		then
			for LIB_TARGET in ${LIBRARY_FILES[@]}
			do
				if [ "$LIB_TARGET" = "$LIB" ]
				then
					DEP_LIBS="${DEP_LIBS} output/lib${LIB}.so"
					CURRENT_BUILD_TARGET_LIBS_NEW="${CURRENT_BUILD_TARGET_LIBS_NEW} -L./output -l${LIB}"
					break
				fi
			done
			unset LIB_TARGET
		else
			CURRENT_BUILD_TARGET_LIBS_NEW="${CURRENT_BUILD_TARGET_LIBS_NEW} ${LIB}" 
		fi
	done
	CURRENT_BUILD_TARGET_LIBS=${CURRENT_BUILD_TARGET_LIBS_NEW}
	unset CURRENT_BUILD_TARGET_LIBS_NEW
	
cat <<_EOF >>Makefile
${CURRENT_BUILD_TARGET_OUTPUT}: ${DEP_LIBS} ${OUTPUT_OBJS[@]}
_EOF
unset DEP_LIBS

	if [ "${CURRENT_BUILD_TARGET}" = "LIB" ]
	then
cat >>Makefile <<_EOF
	g++ -g -shared -W1,-soname,lib${CURRENT_BUILD_TARGET_NAME}.so ${CURRENT_BUILD_TARGET_DEFINES} ${CURRENT_BUILD_TARGET_LIBS} ${OUTPUT_OBJS[@]} -o ${CURRENT_BUILD_TARGET_OUTPUT} -lc

_EOF
	else
cat >>Makefile <<_EOF
	g++ -Wall ${CURRENT_BUILD_TARGET_DEFINES} ${CURRENT_BUILD_TARGET_LIBS} ${OUTPUT_OBJS[@]} -o ${CURRENT_BUILD_TARGET_OUTPUT}

_EOF
	fi

	#TODO: OBJS
	
	CUR_SOURCE_INDEX=0
	if [ "${CURRENT_BUILD_TARGET}" = "LIB" ]
	then
	
		for SOURCE_FILE in ${CURRENT_BUILD_TARGET_SOURCES}
		do
cat >>Makefile <<_EOF
${OUTPUT_OBJS[${CUR_SOURCE_INDEX}]}: ${SOURCE_FILE}
	g++ -fPIC -Wall -g -c -o ${OUTPUT_OBJS[${CUR_SOURCE_INDEX}]} ${CURRENT_BUILD_TARGET_INCLUDES} ${CURRENT_BUILD_TARGET_DEFINES} ${SOURCE_FILE}

_EOF
			let CUR_SOURCE_INDEX=CUR_SOURCE_INDEX+1
		done
	
	else
	
		for SOURCE_FILE in ${CURRENT_BUILD_TARGET_SOURCES}
		do
cat >>Makefile <<_EOF
${OUTPUT_OBJS[${CUR_SOURCE_INDEX}]}: ${SOURCE_FILE}
	g++ -Wall -c -o ${OUTPUT_OBJS[${CUR_SOURCE_INDEX}]} ${CURRENT_BUILD_TARGET_INCLUDES} ${CURRENT_BUILD_TARGET_DEFINES} ${SOURCE_FILE}

_EOF
			let CUR_SOURCE_INDEX=CUR_SOURCE_INDEX+1
		done
	
	fi

done

# Makefile sections install, uninstall and strip

cat <<_EOF >>Makefile
install: all
	@exec ./install.sh
	
uninstall:
	@exec ./uninstall.sh
	
strip: all
_EOF

for I in ${TARGETS_OUTPUT_FILES[@]}
do
cat <<_EOF >>Makefile
	strip ${I}
_EOF
done

cat <<_EOF >>Makefile

clean:
_EOF

for I in ${CLEAN_OUTPUTS} ${CLEAN_OBJS}
do
cat <<_EOF >>Makefile
	@rm -f "$I" >/dev/null 2>&1
_EOF
done

echo "done."

Docela prasácky napsaný, ne zrovna 3x rychlé, ale funguje. Taky si můžete všimnout, že Toolkit se hezky přidá do databáze pkg-config :)

Toolkit má už 7248 řádků :) a má asi 250 kB po kompilaci. Bohužel však stále chybí dodělat spousta widgetů, ale to hlavní už funguje. Zatím jsem s tím udělal hlavní okno JXP Commanderu + about dialog. Není to moc, ale postupuju. Do konce roku už by mohla být funkční a stabilní verze JXP Commanderu. Možná k Vánocům pod stromeček :)

       

Komentáře

[Jan Jílek]

Neumím programovat, ale ocenuji vasi vytrvalost. Tesim se na komander.

[David Watzke]

[ -f Toolkit/Config.h ] && rm -f Toolkit/Config.h
if [ -f Toolkit/Config.h ]
then
    echo "failed."
    echo "ERROR: File Toolkit/Config.h exists in filesystem and could not be removed."
    FAIL
fi

bych nahradil třeba za

rm Toolkit/Config.h 2>/dev/null || \
{
    echo "failed."
    echo "ERROR: File Toolkit/Config.h exists in filesystem and could not be removed."
    FAIL
}

Protože rm -f nevrací 1, když soubor neexistuje, tak raději -f nepoužijeme... A dvakrát checkovat jestli soubor existuje? Nebude lepší raději kontrolovat návraťák?

[David Watzke]

A zase tam vidím cat a za ním deset sedů... ach jo

[Josef Kufner]

Jojo, je to zlé... tak malá ukázka, jak to může být hezčejší:

sed	-e 'vyraz1' \
	-e 'vyraz2' \
	-e 'vyraz3' \
< nejaky_soubor

Výhodou oproti zápisu do jednoho -e '' se středníky to má tu, že v případě chyby sed řekne číslo řádku na kterém je, což odpovídá pořadí -e.

[Zdeněk Burda]

Připadá mi to strašně složitý...

[Michal Kubeček]

To bude tím, že to složité je. :-) Ale pořád jednodušší než obvyklý configure skript generovaný autoconfem - jenže ten aspoň člověk nemusí udržovat a upravovat…

[Josef Kufner]

Ale taky je tu ještě jednodušší cesta, která sice nemusí nemusí fungovat vždy, ale aspoň je to jednoduší :)

Kdysi jsem si napsal mfgen, což je jen bash script, který vygeneruje klasický makefile s tím, že závislosti nechá na gcc a zachovává konfiguraci uloženou ve výsledném makefile. Na nesložité programy je to IMHO dobře použitelné. Používám to celkem dlouho a jediné co jsem kdy dělal, tak bylo dopsání cílů na konec scriptu pro selftesty. Trošku mi tam chybí podpora pro pkgconfig, takže až budu něco psát, tak ji tam asi dodělám. Funguje jak s C, tak s C++.

[Stanislav Bohm]

Pred dlouhou dobou jsem na mfgen narazil a dodnes ho na male testovaci programky pouzivam, velmi uzitecna vec. Dekuji za jeho vytvoreni :)