You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koreader/kodev

1230 lines
36 KiB
Bash

#!/usr/bin/env bash
is_mac() {
if [ "$(uname -s)" != "Darwin" ]; then
echo "You need a mac to build this package"
exit 1
fi
}
CURDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
VERSION="$(git describe HEAD)"
# Only append date if we're not on a whole version, like v2018.11
if echo "${VERSION}" | grep -q -- "-"; then
VERSION="${VERSION}_$(git describe HEAD | xargs git show -s --format=format:"%cd" --date=short)"
fi
# Default Android build to arm.
ANDROID_ARCH="${ANDROID_ARCH:-arm}"
# Default to Android 4.0+; required for NDK 15 but with a custom NDK the strict minimum is 9.
NDKABI="${NDKABI:-14}"
export NDKABI
# Default android flavor
ANDROID_FLAVOR="${ANDROID_FLAVOR:-rocks}"
export ANDROID_FLAVOR
function assert_ret_zero() {
if [ "${1}" -ne 0 ]; then
if [ -n "${2}" ]; then
echo "${2}"
fi
exit 1
fi
}
function check_submodules() {
if git submodule status | grep -qE '^\-'; then
kodev-fetch-thirdparty
fi
}
# Takes two arguments:
# $1 arguments to pass to pgrep
# $2 process name to pgrep for
function gnuplot_wrapper() {
# inspired by https://gist.github.com/nicolasazrak/32d68ed6c845a095f75f037ecc2f0436
trap capture_ctrl_c INT
TEMP_DIR="$(mktemp --directory /tmp/tmp.koreaderXXX)"
LOG="${TEMP_DIR}/memory.log"
SCRIPT_PNG="${TEMP_DIR}/script_png.p"
SCRIPT_SHOW="${TEMP_DIR}/script_show.p"
IMAGE_PNG="${TEMP_DIR}/graph.png"
echo "Memory plot output to ${TEMP_DIR}"
cat >"${SCRIPT_PNG}" <<EOL
set term pngcairo size 1600,1200
set output "${IMAGE_PNG}"
set ylabel "RSS"
set y2label "VSZ"
set ytics nomirror
set y2tics nomirror in
set yrange [0:*]
set y2range [0:*]
plot "${LOG}" using 3 with lines axes x1y1 title "RSS", "${LOG}" using 2 with lines axes x1y2 title "VSZ"
EOL
cat >"${SCRIPT_SHOW}" <<EOL
set term wxt noraise
set ylabel "RSS"
set y2label "VSZ"
set ytics nomirror
set y2tics nomirror in
set yrange [0:*]
set y2range [0:*]
plot "${LOG}" using 3 with lines axes x1y1 title "RSS", "${LOG}" using 2 with lines axes x1y2 title "VSZ"
pause 1
reread
EOL
function capture_ctrl_c() {
kill "${LOOP_PID}"
kill "${GNUPLOT_PID}"
gnuplot "${SCRIPT_PNG}"
exit
}
# initialize at 0 so gnuplot has something to show
echo "0 0 0" >"${LOG}"
while true; do
# shellcheck disable=SC2086
ps -p "$(pgrep --delimiter ' ' $1 "$2")" -o pid=,vsz=,rss= >>"${LOG}"
sleep 1
done &
LOOP_PID=$!
gnuplot "${SCRIPT_SHOW}" &
GNUPLOT_PID=$!
}
function setup_env() {
SETUP_ENV_GREP_COMMAND="grep -z -v debug"
if [ -n "${KODEBUG}" ]; then
SETUP_ENV_GREP_COMMAND="grep -z debug"
# for android adb install
KODEBUG_SUFFIX=-debug
fi
local files=()
while IFS= read -r -d $'\0'; do
files+=("${REPLY}")
done < <(find . -maxdepth 1 -name 'koreader-emulator-*' -print0 | ${SETUP_ENV_GREP_COMMAND})
test ${#files[@]} -gt 0
assert_ret_zero $? "Emulator not found. Please build it first."
local idx=0
# Warn if multiple matches were found
if [ ${#files[@]} -gt 1 ]; then
echo "Multiple emulator builds found:"
local ts=()
# Store list of ts at the same index
for i in "${!files[@]}"; do
local file="${files[${i}]}/koreader"
if [ -d "${file}" ]; then
echo "${file} (last modified on $(stat -c %y "${file}"))"
ts[${i}]="$(stat -c %Y "${file}")"
fi
done
# Sort the list of ts
local sorted_ts=()
IFS=$'\n' read -d '' -r -a sorted_ts < <(printf '%s\n' "${ts[@]}" | sort -r)
# Find the id of the most recent ts (spoiler: it's going to be the one currently targeted by this invocation of kodev)
for i in "${!ts[@]}"; do
if [ "${ts[${i}]}" == "${sorted_ts[0]}" ]; then
idx="${i}"
break
fi
done
# Recap
echo "Picking the most recent one: ${files[${idx}]}/koreader"
fi
EMU_DIR="${files[${idx}]}/koreader"
export EMU_DIR
KO_LD_LIBRARY_PATH="$(realpath "${EMU_DIR}")/libs:${LD_LIBRARY_PATH}"
# Don't export it to avoid messing with tools (e.g., debuggers).
# We'll pass it to LuaJIT via env
}
function kodev-fetch-thirdparty() {
make fetchthirdparty
}
SUPPORTED_TARGETS="
kindle Compatible with all Kindle models >= Kindle4
kindlepw2 With compiler optimizations for Kindle models >= Paperwhite 2
kindle-legacy Needed only for Kindle2/3/DXG
kobo
cervantes
remarkable
sony-prstux
android
pocketbook
ubuntu-touch
appimage
debian Debian package for current arch
debian-armel Debian package for generic armel devices
debian-armhf Debian package for generic armhf devices
debian-arm64 Debian package for generic 64 bits arm devices
macos MacOS app bundle. You need a mac to build this package
emu (*default) If no TARGET is given, assume emulator
win32
"
function kodev-build() {
BUILD_HELP_MSG="
usage: build <OPTIONS> <TARGET>
OPTIONS:
-v, --verbose make the buildsystem more verbose
-d, --debug include debugging symbols (default for emulator)
-n, --no-debug no debugging symbols (default for target devices)
TARGET:
${SUPPORTED_TARGETS}"
declare opt
declare -r E_OPTERR=85
declare -r short_opts="vhnd"
declare -r long_opts="verbose,help,no-debug,debug"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${BUILD_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-v | --verbose)
export VERBOSE=1
;;
-h | --help)
echo "${BUILD_HELP_MSG}"
exit 0
;;
-n | --no-debug)
export KODEBUG=
KODEBUG_NO_DEFAULT=1
;;
-d | --debug)
export KODEBUG=1
KODEBUG_NO_DEFAULT=1
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${BUILD_HELP_MSG}"
exit 8
;;
esac
shift
done
shift
check_submodules
case "${1}" in
cervantes)
make TARGET=cervantes
assert_ret_zero $?
;;
kindle)
make TARGET=kindle
assert_ret_zero $?
;;
kindlepw2)
make TARGET=kindlepw2
assert_ret_zero $?
;;
kobo)
make TARGET=kobo
assert_ret_zero $?
;;
remarkable)
make TARGET=remarkable
assert_ret_zero $?
;;
sony-prstux)
make TARGET=sony-prstux
assert_ret_zero $?
;;
kindle-legacy)
make TARGET=kindle-legacy
assert_ret_zero $?
;;
android)
if [ -z "${NDK}" ]; then
if [ -n "${ANDROID_NDK_HOME}" ]; then
# some distributions use `ANDROID_NDK` instead, fall back to it
export NDK="${ANDROID_NDK_HOME}"
else
export NDK="${CURDIR}/base/toolchain/android-ndk-r15c"
fi
fi
[ -e "${CURDIR}/base/toolchain/android-toolchain-${ANDROID_ARCH}/bin/" ] || {
{ [ -e "${NDK}" ] || make -C "${CURDIR}/base/toolchain" android-ndk; }
assert_ret_zero $?
make android-toolchain
assert_ret_zero $?
}
echo "Using NDK: ${NDK}..."
make TARGET=android
assert_ret_zero $?
;;
pocketbook)
make TARGET=pocketbook
assert_ret_zero $?
;;
ubuntu-touch)
make TARGET=ubuntu-touch
assert_ret_zero $?
;;
appimage)
make TARGET=appimage
assert_ret_zero $?
;;
debian)
make TARGET=debian
assert_ret_zero $?
;;
debian-armel)
make TARGET=debian-armel
assert_ret_zero $?
;;
debian-armhf)
make TARGET=debian-armhf
assert_ret_zero $?
;;
debian-arm64)
make TARGET=debian-arm64
assert_ret_zero $?
;;
macos)
is_mac
make TARGET=macos
assert_ret_zero $?
;;
win32)
make TARGET=win32
assert_ret_zero $?
;;
*)
if [ -z "${KODEBUG_NO_DEFAULT}" ]; then # no explicit --debug / --no-debug
# builds a debug build by default, like kodev-run
export KODEBUG=1
fi
make
assert_ret_zero $? "Failed to build emulator! Try run with -v for more information."
setup_env
;;
esac
}
function kodev-clean() {
CLEAN_HELP_MSG="
usage: clean <TARGET>
TARGET:
${SUPPORTED_TARGETS}"
declare opt
declare -r E_OPTERR=85
declare -r short_opts="nd"
declare -r long_opts="no-debug,debug"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${CLEAN_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-n | --no-debug)
export KODEBUG=
KODEBUG_NO_DEFAULT=1
;;
-d | --debug)
export KODEBUG=1
KODEBUG_NO_DEFAULT=1
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${BUILD_HELP_MSG}"
exit 8
;;
esac
shift
done
shift
case "${1}" in
-h | --help)
echo "${CLEAN_HELP_MSG}"
exit 0
;;
cervantes)
make TARGET=cervantes clean
;;
kindle)
make TARGET=kindle clean
;;
kindlepw2)
make TARGET=kindlepw2 clean
;;
kobo)
make TARGET=kobo clean
;;
remarkable)
make TARGET=remarkable clean
;;
sony-prstux)
make TARGET=sony-prstux clean
;;
kindle-legacy)
make TARGET=kindle-legacy clean
;;
android)
make TARGET=android clean
rm -f ./*.apk
;;
pocketbook)
make TARGET=pocketbook clean
;;
ubuntu-touch)
make TARGET=ubuntu-touch clean
;;
appimage)
make TARGET=appimage clean
;;
debian)
make TARGET=debian clean
;;
debian-armel)
make TARGET=debian-armel clean
;;
debian-armhf)
make TARGET=debian-armhf clean
;;
debian-arm64)
make TARGET=debian-arm64 clean
;;
macos)
is_mac
make TARGET=macos clean
;;
win32)
make TARGET=win32 clean
;;
*)
if [ -z "${KODEBUG_NO_DEFAULT}" ]; then
# No explicit --debug / --no-debug
# Builds a debug build by default, like kodev-run
export KODEBUG=1
fi
make clean
;;
esac
}
function kodev-release() {
# SUPPORTED_RELEASE_TARGETS=$(echo ${SUPPORTED_TARGETS} | sed 's/win32//')
SUPPORTED_RELEASE_TARGETS="${SUPPORTED_TARGETS/emu*/""}"
RELEASE_HELP_MSG="
usage: release <OPTIONS> <TARGET>
OPTIONS:
-d, --debug debug-enabled release (for remote gdb)
-i, --ignore-translation do not fetch translation for release
-v, --verbose make the buildsystem more verbose
TARGET:
${SUPPORTED_RELEASE_TARGETS}"
[ $# -lt 1 ] && {
echo "${RELEASE_HELP_MSG}"
exit 1
}
# Defaults
ignore_translation=0
declare opt
declare -r E_OPTERR=85
declare -r short_opts="divh"
declare -r long_opts="debug,ignore-translation,verbose,help"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${RELEASE_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-d | --debug)
export KODEBUG=1
;;
-i | --ignore-translation)
ignore_translation=1
;;
-v | --verbose)
export VERBOSE=1
;;
-h | --help)
echo "${RELEASE_HELP_MSG}"
exit 0
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${RELEASE_HELP_MSG}"
exit 1
;;
esac
shift
done
shift
check_submodules
if [ "${ignore_translation}" -eq 0 ]; then
make po || {
echo "ERROR: failed to fetch translation."
echo "Tip: Use --ignore-translation OPTION if you want to build a release without translation."
exit 1
}
fi
case "${1}" in
kindle)
kodev-build kindle
make TARGET=kindle update
;;
kindlepw2)
kodev-build kindlepw2
make TARGET=kindlepw2 update
;;
kobo)
kodev-build kobo
make TARGET=kobo update
;;
remarkable)
kodev-build remarkable
make TARGET=remarkable update
;;
sony-prstux)
kodev-build sony-prstux
make TARGET=sony-prstux update
;;
cervantes)
kodev-build cervantes
make TARGET=cervantes update
;;
kindle-legacy)
kodev-build kindle-legacy
make TARGET=kindle-legacy update
;;
android)
kodev-build android
export PATH=${PATH}:${CURDIR}/base/toolchain/android-sdk-linux/tools
command -v android &>/dev/null || {
make -C "${CURDIR}/base/toolchain" android-sdk
}
ANDROID_HOME=$(dirname "$(dirname "$(command -v android)")")
export ANDROID_HOME
export PATH="${PATH}:${NDK}"
make TARGET=android update
;;
pocketbook)
kodev-build pocketbook
make TARGET=pocketbook update
;;
ubuntu-touch)
kodev-build ubuntu-touch
make TARGET=ubuntu-touch update
;;
appimage)
kodev-build appimage
make TARGET=appimage update
;;
debian)
kodev-build debian
make TARGET=debian update
;;
debian-armel)
kodev-build debian-armel
make TARGET=debian-armel update
;;
debian-armhf)
kodev-build debian-armhf
make TARGET=debian-armhf update
;;
debian-arm64)
kodev-build debian-arm64
make TARGET=debian-arm64 update
;;
macos)
is_mac
kodev-build macos
make TARGET=macos update
;;
*)
echo "Unsupported target for release: $1."
echo "${RELEASE_HELP_MSG}"
exit 1
;;
esac
}
function kodev-wbuilder() {
kodev-build
echo "[*] Running wbuilder.lua..."
pushd "${EMU_DIR}" && {
EMULATE_READER_W=540 EMULATE_READER_H=720 ./luajit ./tools/wbuilder.lua
} && popd || exit
}
function kodev-run() {
RUN_HELP_MSG="
usage: run <OPTIONS> <TARGET>
OPTIONS:
-h X, --screen-height=X set height of the emulator screen (default: 720)
-w X, --screen-width=X set width of the emulator screen (default: 540)
-d X, --screen-dpi=X set DPI of the emulator screen (default: 160)
-b, --no-build run reader without rebuilding
-n, --no-debug no debugging symbols (requires rebuilding)
-t, --disable-touch use this if you want to simulate keyboard only devices
-s FOO --simulate=FOO simulate dimension and other specs for a given device model
supported model: hidpi, kobo-forma, kobo-aura-one, kobo-clara, kindle-paperwhite, kobo-h2o, legacy-paperwhite, kindle
-g X, --gdb=X run with debugger (default: nemiver)
-p, --graph graph memory use (requires gnuplot)
-v X, --valgrind=X run with valgrind (default: \"valgrind --tool=memcheck --trace-children=yes --leak-check=full --track-origins=yes --show-reachable=yes\")
-c, --callgrind run with valgrind's callgrind (valgrind --tool=callgrind --trace-children=yes)
-S, --no-catchsegv prevents wrapping by catchsegv
TARGET:
android install and run KOReader on an Android device connected through ADB
"
# NOTE: Speaking of Valgrind, if your libdrm/mesa isn't built w/ valgrind markings, there's a Valgrind suppression file for AMD cards in the tools folder.
# Just append --suppressions=${PWD/tools/valgrind_amd.supp to your valgrind command.
# Defaults
screen_width=540
screen_height=720
export KODEBUG=1
declare opt
declare -r E_OPTERR=85
declare -r short_opts="tbng::pv::cw:h:d:s:SH"
declare -r long_opts="disable-touch,no-build,gdb::,graph,valgrind::,callgrind,screen-width:,screen-height:,screen-dpi:,simulate:,no-catchsegv,help"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${RUN_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-t | --disable-touch)
export DISABLE_TOUCH=1
;;
-b | --no-build)
no_build=1
;;
-n | --no-debug)
export KODEBUG=
;;
-g | --gdb)
if [ -n "${VALUE}" ]; then
gdb="${VALUE}"
else
# Try to use friendly defaults for gdb
if command -v nemiver >/dev/null; then
# Nemiver is a nice GUI
gdb="nemiver"
elif command -v ddd >/dev/null; then
# DDD is a slightly less nice GUI
gdb="ddd"
elif command -v cgdb >/dev/null; then
# cgdb is a nice curses-based gdb front
gdb="cgdb"
elif command -v gdb >/dev/null; then
# gdb -tui is a slightly less nice terminal user interface
gdb="gdb -tui"
else
echo "Couldn't find gdb."
exit 1
fi
fi
shift
;;
-p | --graph)
graph_memory=1
;;
-v | --valgrind)
if [ -n "${VALUE}" ]; then
valgrind="${VALUE}"
else
# Try to use sensible defaults for valgrind
if command -v valgrind >/dev/null; then
valgrind="valgrind --tool=memcheck --trace-children=yes --leak-check=full --track-origins=yes --show-reachable=yes"
else
echo "Couldn't find valgrind."
exit 1
fi
fi
shift
;;
-c | --callgrind)
# Try to use sensible defaults for valgrind
if command -v valgrind >/dev/null; then
valgrind="valgrind --tool=callgrind --trace-children=yes"
else
echo "Couldn't find valgrind."
exit 1
fi
;;
-w | --screen-width)
screen_width=${VALUE}
shift
;;
-h | --screen-height)
# simple numeric check due to overlap between -h for help and height
if [ -n "${VALUE##*[!0-9]*}" ]; then
screen_height=${VALUE}
else
echo "ERROR: Invalid value: \"${VALUE}\""
echo "${RUN_HELP_MSG}"
exit 1
fi
shift
;;
-d | --screen-dpi)
screen_dpi=${VALUE}
shift
;;
-s | --simulate)
device_model="${VALUE}"
case "${device_model}" in
kindle)
screen_width=600
screen_height=800
screen_dpi=167
;;
legacy-paperwhite)
screen_width=758
screen_height=1024
screen_dpi=212
;;
kobo-forma)
screen_width=1440
screen_height=1920
screen_dpi=300
;;
kobo-aura-one)
screen_width=1404
screen_height=1872
screen_dpi=300
;;
kobo-clara | kindle-paperwhite)
screen_width=1072
screen_height=1448
screen_dpi=300
;;
kobo-h2o)
screen_width=1080
screen_height=1429
screen_dpi=265
;;
hidpi)
screen_width=1500
screen_height=2000
screen_dpi=600
;;
*)
echo "ERROR: spec unknown for ${device_model}."
;;
esac
shift
;;
-S | --no-catchsegv)
no_catchsegv=1
;;
-H | --help)
echo "${RUN_HELP_MSG}"
exit 0
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${RUN_HELP_MSG}"
exit 8
;;
esac
shift
done
shift
case "${1}" in
android)
command -v adb >/dev/null && {
if [ -z "${no_build}" ]; then
echo "[*] Building KOReader for Android…"
kodev-release --ignore-translation android
assert_ret_zero $?
fi
setup_env
# clear logcat to get rid of useless cruft
adb logcat -c
# uninstall existing package to make sure *everything* is gone from memory
# no assert_ret_zero; uninstall is allowed to fail if there's nothing to uninstall
adb uninstall "org.koreader.launcher"
adb install "koreader-android-${ANDROID_ARCH}${KODEBUG_SUFFIX}-${VERSION}.apk"
assert_ret_zero $?
# there's no adb run so we do this…
adb shell monkey -p org.koreader.launcher -c android.intent.category.LAUNCHER 1
assert_ret_zero $?
adb logcat KOReader:V luajit-launcher:V "*:E"
} || echo "Failed to find adb in PATH to interact with Android device."
;;
*)
if [ -z "${no_build}" ]; then
echo "[*] Building KOReader…"
if [ -z "${KODEBUG}" ]; then
kodev-build --no-debug
else
kodev-build
fi
else
setup_env
fi
if [ ! -d "${EMU_DIR}" ]; then
echo "Failed to find emulator directory! Please try build command first."
exit 1
fi
if [ -n "${graph_memory}" ]; then
gnuplot_wrapper "--parent $$" "reader.lua"
fi
KOREADER_ARGS="-d"
KOREADER_COMMAND="env LD_LIBRARY_PATH=${KO_LD_LIBRARY_PATH} ./reader.lua ${KOREADER_ARGS}"
# run with catchsegv by default when it is available (unless no-catchsegv is enabled, c.f., #7036)
# see https://github.com/koreader/koreader/issues/2878#issuecomment-326796777
if [ -z "${no_catchsegv}" ]; then
if command -v catchsegv >/dev/null; then
KOREADER_COMMAND="$(command -v catchsegv) ${KOREADER_COMMAND}"
fi
fi
if [ -n "${valgrind}" ]; then
KOREADER_COMMAND="${valgrind} env LD_LIBRARY_PATH=${KO_LD_LIBRARY_PATH} ./luajit reader.lua ${KOREADER_ARGS}"
fi
echo "[*] Running KOReader with arguments: $* ..."
pushd "${EMU_DIR}" && {
if [ $# -ge 1 ]; then
args="$*"
[[ "${args}" != /* ]] && args="${CURDIR}/${args}"
fi
if [ -n "${gdb}" ]; then
# We don't want to stack valgrind/catchsegv on top of GDB ;).
if [[ "${gdb}" == gdb* ]]; then
# The standard CLI needs a little hand holding to properly pass arguments to the process it'll monitor
KOREADER_COMMAND="${gdb} --args env LD_LIBRARY_PATH=${KO_LD_LIBRARY_PATH} ./luajit reader.lua ${KOREADER_ARGS} ${args}"
else
KOREADER_COMMAND="${gdb} env LD_LIBRARY_PATH=${KO_LD_LIBRARY_PATH} ./luajit reader.lua ${KOREADER_ARGS} ${args}"
fi
else
KOREADER_COMMAND="${KOREADER_COMMAND} ${args}"
fi
RETURN_VALUE=85
while [ "${RETURN_VALUE}" -eq 85 ]; do
# shellcheck disable=SC2086
env EMULATE_READER_W="${screen_width}" EMULATE_READER_H="${screen_height}" EMULATE_READER_DPI="${screen_dpi}" \
${KOREADER_COMMAND}
RETURN_VALUE=$?
done
} && popd || exit
if [ -n "${graph_memory}" ]; then
capture_ctrl_c
fi
exit ${RETURN_VALUE}
;;
esac
}
function kodev-test() {
TEST_HELP_MSG="
usage: test <OPTIONS> [front|base] <TEST_NAME>
TEST_NAME is optional. If no TEST_NAME is given, all tests will be run.
OPTIONS:
-p, --graph graph memory use (requires gnuplot)
-n, --no-debug no debugging symbols (default for target devices)
-t, --tags=TAGS only run tests with given tags
"
declare opt
declare -r E_OPTERR=85
declare -r short_opts="pt:nh"
declare -r long_opts="graph,tags:,no-debug,help"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${TEST_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-p | --graph)
graph_memory=1
;;
-n | --no-debug)
export KODEBUG=
KODEBUG_NO_DEFAULT=1
;;
-t | --tags)
opts="--tags=${VALUE}"
shift
;;
-h | --help)
echo "${TEST_HELP_MSG}"
exit 0
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${TEST_HELP_MSG}"
exit 8
;;
esac
shift
done
shift
[ $# -lt 1 ] && {
echo "${TEST_HELP_MSG}"
exit 1
}
[[ "${1}" != "front" && "${1}" != "base" ]] && {
echo "Invalid test suite: $1!"
echo "${TEST_HELP_MSG}"
exit 1
}
set -e
check_submodules && kodev-build
setup_env
make "${EMU_DIR}/.busted"
pushd "${EMU_DIR}" && {
test_path_basedir="./spec/$1/unit"
rm -rf "${test_path_basedir}"/data/*.sdr
test_path="${test_path_basedir}"
if [ -n "${2}" ]; then
test_path="${test_path_basedir}/$2"
fi
echo "Running tests in" "${test_path}"
env LD_LIBRARY_PATH="${KO_LD_LIBRARY_PATH}" \
busted --lua="./luajit" "${opts}" \
--output=gtest \
--lpath="${test_path_basedir}/?.lua" \
--exclude-tags=notest "${test_path}"
} && popd || exit
}
function kodev-cov() {
COV_HELP_MSG="
usage: cov <OPTIONS>
OPTIONS:
-f, --full show full coverage report (down to each line)
-s, --show-previous show coverage stats from previous run
-n, --no-debug no debugging symbols (default for target devices)
"
# Defaults
show_full=0
show_previous=0
declare opt
declare -r E_OPTERR=85
declare -r short_opts="fsn"
declare -r long_opts="full,show-previous,no-debug"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${COV_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-f | --full)
show_full=1
;;
-s | --show-previous)
show_previous=1
;;
-n | --no-debug)
export KODEBUG=
KODEBUG_NO_DEFAULT=1
;;
-h | --help)
echo "${COV_HELP_MSG}"
exit 0
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${COV_HELP_MSG}"
exit 8
;;
esac
shift
done
shift
set -e
check_submodules && kodev-build
setup_env
make "${EMU_DIR}/.busted"
pushd "${EMU_DIR}" && {
target=front
test_path="./spec/${target}/unit"
if [ "${show_previous}" -eq 0 ]; then
echo "Running tests in" ${test_path}
env LD_LIBRARY_PATH="${KO_LD_LIBRARY_PATH}" \
busted --lua="./luajit" \
--sort-files \
-o "./spec/${target}/unit/verbose_print" \
--coverage \
--exclude-tags=nocov "${test_path}" || {
echo "Failed to run tests!" && exit 1
}
fi
if [ "${show_full}" -eq 1 ]; then
cat luacov.report.out
else
LUACOV_REPORT_SUMMARY=$(grep -nm1 -e '^Summary$' luacov.report.out | cut -d: -f1)
tail -n \
+$((LUACOV_REPORT_SUMMARY - 1)) \
luacov.report.out
fi
} && popd || exit
}
function kodev-log() {
LOG_HELP_MSG="
usage: log <OPTIONS> <TARGET>
OPTIONS:
-d, --debug more verbose logs (e.g., debug builds)
TARGET:
android
"
[ $# -lt 1 ] && {
echo "${LOG_HELP_MSG}"
exit 1
}
# Defaults
ignore_translation=0
declare opt
declare -r E_OPTERR=85
declare -r short_opts="dh"
declare -r long_opts="debug, help"
if ! opt=$(getopt -o "${short_opts}" --long "${long_opts}" --name "kodev" -- "${@}"); then
echo "${LOG_HELP_MSG}"
exit ${E_OPTERR}
fi
eval set -- "${opt}"
while true; do
PARAM="${1}"
# Support using an = assignment with short options (e.g., -f=blah instead of -f blah).
VALUE="${2/#=/}"
case "${PARAM}" in
-d | --debug)
export KODEBUG=1
;;
-h | --help)
echo "${LOG_HELP_MSG}"
exit 0
;;
--)
break
;;
*)
echo "ERROR: unknown option \"${PARAM}\""
echo "${RELEASE_HELP_MSG}"
exit 1
;;
esac
shift
done
shift
case "${1}" in
android)
if [ -n "${KODEBUG}" ]; then
adb logcat 'KOReader:* ActivityManager:* AndroidRuntime:* DEBUG:* *:F dlopen:* LuaJIT:*'
else
adb logcat 'KOReader:I ActivityManager:* AndroidRuntime:* DEBUG:* *:F'
fi
;;
*)
echo "Unsupported target: $1."
echo "${LOG_HELP_MSG}"
exit 1
;;
esac
}
HELP_MSG="
usage: $0 COMMAND <ARGS>
Supported commands:
activate Bootstrap shell environment for kodev
build Build KOReader
clean Clean KOReader build
fetch-thirdparty Fetch thirdparty dependencies for build
log Tail log stream for a running KOReader app
release Build KOReader release package
run Run KOReader
test Run busted tests
check Run luacheck static-analysis
cov Run busted tests for coverage
wbuilder Run wbuilder.lua script (useful for building new UI widget)
prompt Run a LuaJIT shell within KOReader's environment
"
[ $# -lt 1 ] && {
echo "Missing command."
echo "${HELP_MSG}"
exit 1
}
case "${1}" in
activate)
echo "adding ${CURDIR} to \$PATH..."
export PATH="${PATH}:${CURDIR}"
eval "$(luarocks path --bin)"
exec "${SHELL}"
;;
fetch-thirdparty)
kodev-fetch-thirdparty
;;
clean)
shift 1
kodev-clean "$@"
;;
build)
shift 1
kodev-build "$@"
;;
release)
shift 1
kodev-release "$@"
;;
wbuilder)
kodev-wbuilder
;;
run)
shift 1
kodev-run "$@"
;;
test)
shift 1
kodev-test "$@"
;;
check)
luacheck -q {reader,setupkoenv,datastorage}.lua frontend plugins spec
;;
cov)
shift 1
kodev-cov "$@"
;;
prompt)
kodev-build
pushd "${EMU_DIR}" && {
env LD_LIBRARY_PATH="${KO_LD_LIBRARY_PATH}" \
./luajit -i setupkoenv.lua
} && popd || exit
;;
log)
shift 1
kodev-log "$@"
;;
-h | --help)
echo "${HELP_MSG}"
exit 0
;;
*)
echo "Unknown command: $1."
echo "${HELP_MSG}"
exit 8
;;
esac