~strahinja/poe

42e09519739068716f9f414c37f85c1224a718cb — Страхиња Радић a month ago ca4ced9 v1.7.3
Switch from redo to POSIX make; update copyright year

Signed-off-by: Страхиња Радић <contact@strahinja.org>
33 files changed, 126 insertions(+), 577 deletions(-)

M INSTALL
A Makefile
M README
D _config.h.do
D all.do
D clean.do
M config.def.h
A config.mk
D config.redo
D default.do
D default.gz.do
D default.o.do
D default.pdf.do
D do
M draw.c
M draw.h
D install.do
R date.do => lib/makedate -rw-r--r-- => -rwxr-xr-x
R version.do => lib/makeversion -rw-r--r-- => -rwxr-xr-x
A lib/mkpack
A lib/replacepat
D pack.do
M po.c
M po.h
M poe.1.in
M poe.c
D poe.do
D rebuild.do
M termbox.h
D uninstall.do
M util.c
M util.h
M version.h.in
M INSTALL => INSTALL +5 -12
@@ 1,7 1,7 @@
Prerequisites
=============

* C compiler - defaults in config.redo
* C compiler - defaults in config.mk


Optional


@@ 16,22 16,15 @@ Install
	$ git clone https://git.sr.ht/~strahinja/poe
	$ cd poe
	$ su

If you have djb redo:

	# redo install

if you don't:

	# ./do install
	# make install


Persistent build configuration file
-----------------------------------

The file config.redo will be sourced when building targets which also accept
The file config.mk will be sourced when building targets which also accept
configuration through environment variables.  For example, CC and PREFIX
are specified in config.redo.
are specified in config.mk.


OpenBSD


@@ 41,7 34,7 @@ Replace gcc in CC with cc and add -D_BSD_SOURCE, eg:

	# CC='cc -g -Wall -pedantic -std=c99 -D_POSIX_C_SOURCE=200809L
		-D_XOPEN_SOURCE=700 -D_BSD_SOURCE -D_DEFAULT_SOURCE}' \
		./do install
		make install

and change MANPREFIX to


A Makefile => Makefile +57 -0
@@ 0,0 1,57 @@
include config.mk

.SUFFIXES: .1.in .1 .def.h .h.in .h .c .o

.1.in.1:
	sh -x lib/replacepat $< > $@

.h.in.h:
	sh -x lib/replacepat $< > $@

all: $(PROG) $(MANPAGE)

config.h: config.def.h
	[ ! -r config.h ] && cp config.def.h config.h || true

date:
	sh lib/makedate

version:
	sh lib/makeversion

poe.o: poe.c config.h draw.h po.h termbox.h util.h version.h

$(MANPAGE): $(MANPAGE).in version date

version.h: version.h.in version date

draw.o: draw.c config.h draw.h po.h termbox.h util.h version.h

util.o: util.c termbox.h po.h util.h

$(PROG): $(OBJS) $(SRC) $(HEADERS)
	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)

clean:
	rm -f version date version.h *.o *.xz *~ $(PROG) $(MANPAGE)

install: all
	$(INSTALL) -Dm 0644 $(MANPAGE) $(MANPREFIX)/man1/$(MANPAGE)
	$(INSTALL) -Dm 0644 README $(DOCDIR)/README
	$(INSTALL) -Dm 0644 LICENSE $(DOCDIR)/LICENSE
	$(INSTALL) -Dm 0755 $(PROG) $(BINDIR)/$(PROG)

uninstall:
	rm -f $(MANPREFIX)/man1/$(MANPAGE)
	rmdir $(MANPREFIX)/man1 2>/dev/null || true
	rmdir $(MANPREFIX) 2>/dev/null || true
	rm -f $(DOCDIR)/README
	rm -f $(DOCDIR)/LICENSE
	rmdir $(DOCDIR) 2>/dev/null || true
	rm -f $(PROG) $(BINDIR)/$(PROG)
	rmdir $(BINDIR) 2>/dev/null || true

pack: all version
	sh -x lib/mkpack

.PHONY: all clean install uninstall pack

M README => README +1 -1
@@ 35,7 35,7 @@ License
-------

poe - .po file editor
Copyright (C) 2021-2023  Страхиња Радић
Copyright (C) 2021-2024  Страхиња Радић

This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software

D _config.h.do => _config.h.do +0 -9
@@ 1,9 0,0 @@
if [ -r config.h ]; then
	redo-ifchange config.h
	cp config.h $3
else
	redo-ifcreate config.h
	redo-ifchange config.def.h
	cp config.def.h $3
	cp config.def.h config.h
fi

D all.do => all.do +0 -2
@@ 1,2 0,0 @@
. ./config.redo
redo-ifchange poe poe.1"$MANSUFFIX"

D clean.do => clean.do +0 -2
@@ 1,2 0,0 @@
. ./config.redo
rm -f *~ *.o poe poe.1"$MANSUFFIX" poe.1 version.h version date _config.h

M config.def.h => config.def.h +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

/* Comment out to not create backups */

A config.mk => config.mk +21 -0
@@ 0,0 1,21 @@
CC		= cc
CFLAGS		= -g -Wall -pedantic -std=c99 -D_POSIX_C_SOURCE=200809L \
		  -D_XOPEN_SOURCE=700
# OpenBSD
#CFLAGS		= -g -Wall -pedantic -std=c99 -D_POSIX_C_SOURCE=200809L \
#		  -D_XOPEN_SOURCE=700 -D_BSD_SOURCE
INSTALL		= install
LIBS		=
SRC		= draw.c po.c poe.c util.c #strlcat.c strlcpy.c
HEADERS		= config.h draw.h po.h termbox.h util.h version.h
OBJS		= draw.o po.o poe.o util.o #strlcat.o strlcpy.o
PREFIX		= /usr/local
PROG		= poe

# Derived macros
BINDIR		= $(PREFIX)/bin
DOCDIR		= $(PREFIX)/share/doc/$(PROG)
MANPREFIX	= $(PREFIX)/share/man
# OpenBSD
#MANPREFIX	= $(PREFIX)/man
MANPAGE		= $(PROG).1

D config.redo => config.redo +0 -21
@@ 1,21 0,0 @@
PREFIX=${PREFIX:-/usr/local}

BINDIR=$PREFIX/bin
DOCDIR=$PREFIX/share/doc/poe
MANPREFIX=$PREFIX/share/man

# OpenBSD
#MANPREFIX=$PREFIX/man

PROGS=poe
DOCS="README LICENSE"
MANSUFFIX=${MANSUFFIX-$(command -v gzip >/dev/null && printf ".gz")}
MANPAGES="poe.1${MANSUFFIX}"

CC=${CC:-gcc -g -Wall -pedantic -std=c99 -D_POSIX_C_SOURCE=200809L \
-D_XOPEN_SOURCE=700 -D_DEFAULT_SOURCE}
STRIP=${STRIP:-:}

# OpenBSD
#CC=${CC:-cc -g -Wall -pedantic -std=c99 -D_POSIX_C_SOURCE=200809L \
#-D_XOPEN_SOURCE=700 -D_BSD_SOURCE -D_DEFAULT_SOURCE}

D default.do => default.do +0 -10
@@ 1,10 0,0 @@
if [ -r $1.in ]; then
	redo-ifchange $1.in version date
	read VERSION <version
	read DATE <date
	sed -e "s/%VERSION%/$VERSION/g" \
		-e "s/%DATE%/$DATE/g" <$1.in >$3
else
	printf "%s: don't know how to build '%s'\n" "$0" "$1" >&2
	exit 99
fi

D default.gz.do => default.gz.do +0 -2
@@ 1,2 0,0 @@
redo-ifchange $2
gzip -cf $2 >$3

D default.o.do => default.o.do +0 -5
@@ 1,5 0,0 @@
sed -n 's/^#include "\([^"]*\)"/\1/p' ${2%.o}.c | \
	xargs redo-ifchange
redo-ifchange $2.c
. ./config.redo
${CC} -c $2.c -o $3

D default.pdf.do => default.pdf.do +0 -2
@@ 1,2 0,0 @@
redo-ifchange $2.1
groff -mandoc -t -T pdf $2.1 >$3

D do => do +0 -446
@@ 1,446 0,0 @@
#!/usr/bin/env sh
#
# A minimal alternative to djb redo that doesn't support incremental builds.
# For the full version, visit http://github.com/apenwarr/redo
#
# The author disclaims copyright to this source file and hereby places it in
# the public domain. (2010 12 14; updated 2019 02 24)
#
USAGE="
usage: do [-d] [-x] [-v] [-c] <targets...>
  -d  print extra debug messages (mostly about dependency checks)
  -v  run .do files with 'set -v'
  -x  run .do files with 'set -x'
  -c  clean up all old targets before starting

  Note: do is an implementation of redo that does *not* check dependencies.
  It will never rebuild a target it has already built, unless you use -c.
"

# CDPATH apparently causes unexpected 'cd' output on some platforms.
unset CDPATH

# By default, no output coloring.
green=""
bold=""
plain=""

if [ -n "$TERM" -a "$TERM" != "dumb" ] && tty <&2 >/dev/null 2>&1; then
	green="$(printf '\033[32m')"
	bold="$(printf '\033[1m')"
	plain="$(printf '\033[m')"
fi

# The 'seq' command is not available on all platforms.
_seq() {
	local x=0 max="$1"
	while [ "$x" -lt "$max" ]; do
		x=$((x + 1))
		echo "$x"
	done
}

# Split $1 into a dir part ($_dirsplit_dir) and base filename ($_dirsplit_base)
_dirsplit() {
	_dirsplit_base=${1##*/}
	_dirsplit_dir=${1%$_dirsplit_base}
}

# Like /usr/bin/dirname, but avoids a fork and uses _dirsplit semantics.
qdirname() (
	_dirsplit "$1"
	dir=${_dirsplit_dir%/}
	echo "${dir:-.}"
)

_dirsplit "$0"
REDO=$(cd "$(pwd -P)" &&
	cd "${_dirsplit_dir:-.}" &&
	echo "$PWD/$_dirsplit_base")
export REDO
_cmd=$_dirsplit_base

DO_TOP=
if [ -z "$DO_BUILT" ]; then
	export _do_opt_debug=
	export _do_opt_exec=
	export _do_opt_verbose=
	export _do_opt_clean=
fi
while getopts 'dxvcj:h?' _opt; do
	case $_opt in
		d) _do_opt_debug=1 ;;
		x) _do_opt_exec=x ;;
		v) _do_opt_verbose=v ;;
		c) _do_opt_clean=1 ;;
		j) ;;  # silently ignore, for compat with real redo
		\?|h|*) printf "%s" "$USAGE" >&2
		   exit 99
		   ;;
	esac
done
shift "$((OPTIND - 1))"
_debug() {
	[ -z "$_do_opt_debug" ] || echo "$@" >&2
}

if [ -z "$DO_BUILT" -a "$_cmd" != "redo-whichdo" ]; then
	DO_TOP=1
	if [ "$#" -eq 0 ] && [ "$_cmd" = "do" -o "$_cmd" = "redo" ]; then
		set all  # only toplevel redo has a default target
	fi
	export DO_STARTDIR="$(pwd -P)"
	# If starting /bin/pwd != $PWD, this will fix it.
	# That can happen when $PWD contains symlinks that the shell is
	# trying helpfully (but unsuccessfully) to hide from the user.
	cd "$DO_STARTDIR" || exit 99
	export DO_BUILT="$PWD/.do_built"
	if [ -z "$_do_opt_clean" -a -e "$DO_BUILT" ]; then
		echo "do: Incremental mode. Use -c for clean rebuild." >&2
	fi
	: >>"$DO_BUILT"
	sort -u "$DO_BUILT" >"$DO_BUILT.new"
	while read f; do
		[ -n "$_do_opt_clean" ] && printf "%s\0%s.did\0" "$f" "$f"
		printf "%s.did.tmp\0" "$f"
	done <"$DO_BUILT.new" |
	xargs -0 rm -f 2>/dev/null
	mv "$DO_BUILT.new" "$DO_BUILT"
	export DO_PATH="$DO_BUILT.dir"
	export PATH="$DO_PATH:$PATH"
	rm -rf "$DO_PATH"
	mkdir "$DO_PATH"
	for d in redo redo-ifchange redo-whichdo; do
		ln -s "$REDO" "$DO_PATH/$d"
	done
	for d in redo-ifcreate redo-stamp redo-always redo-ood \
	    redo-targets redo-sources; do
	        echo "#!/bin/sh" >"$DO_PATH/$d"
		chmod a+rx "$DO_PATH/$d"
	done
fi


# Chop the "file" part off a /path/to/file pathname.
# Note that if the filename already ends in a /, we just remove the slash.
_updir()
{
	local v="${1%/*}"
	[ "$v" != "$1" ] && echo "$v"
	# else "empty" which means we went past the root
}


# Returns true if $1 starts with $2.
_startswith()
{
	[ "${1#"$2"}" != "$1" ]
}


# Returns true if $1 ends with $2.
_endswith()
{
	[ "${1%"$2"}" != "$1" ]
}


# Prints $1 if it's absolute, or $2/$1 if $1 is not absolute.
_abspath()
{
	local here="$2" there="$1"
	if _startswith "$1" "/"; then
		echo "$1"
	else
		echo "$2/$1"
	fi
}


# Prints $1 as a path relative to $PWD (not starting with /).
# If it already doesn't start with a /, doesn't change the string.
_relpath()
{
	local here="$2" there="$1" out= hadslash=
	#echo "RP start '$there' hs='$hadslash'" >&2
	_startswith "$there" "/" || { echo "$there" && return; }
	[ "$there" != "/" ] && _endswith "$there" "/" && hadslash=/
	here=${here%/}/
	while [ -n "$here" ]; do
		#echo "RP out='$out' here='$here' there='$there'" >&2
		[ "${here%/}" = "${there%/}" ] && there= && break;
		[ "${there#$here}" != "$there" ] && break
		out=../$out
		_dirsplit "${here%/}"
		here=$_dirsplit_dir
	done
	there=${there#$here}
	if [ -n "$there" ]; then
		echo "$out${there%/}$hadslash"
	else
		echo "${out%/}$hadslash"
	fi
}


# Prints a "normalized relative" path, with ".." resolved where possible.
# For example, a/b/../c will be reduced to just a/c.
_normpath()
(
	local path="$1" relto="$2" out= isabs=
	#echo "NP start '$path'" >&2
	if _startswith "$path" "/"; then
		isabs=1
	else
		path="${relto%/}/$path"
	fi
	set -f
	IFS=/
	for d in ${path%/}; do
		#echo "NP out='$out' d='$d'" >&2
		if [ "$d" = ".." ]; then
			out=$(_updir "${out%/}")/
		else
			out=$out$d/
		fi
	done
	#echo "NP out='$out' (done)" >&2
	out=${out%/}
	if [ -n "$isabs" ]; then
		echo "${out:-/}"
	else
		_relpath "${out:-/}" "$relto"
	fi
)


# Prints a "real" path, with all symlinks resolved where possible.
_realpath()
{
	local path="$1" relto="$2" isabs= rest=
	if _startswith "$path" "/"; then
		isabs=1
	else
		path="${relto%/}/$path"
	fi
	(
		for d in $(_seq 100); do
			#echo "Trying: $PWD--$path" >&2
			if cd -P "$path" 2>/dev/null; then
				# success
				pwd=$(pwd -P)
				#echo "  chdir ok: $pwd--$rest" >&2
				np=$(_normpath "${pwd%/}/$rest" "$relto")
				if [ -n "$isabs" ]; then
					echo "$np"
				else
					_relpath "$np" "$relto"
				fi
				break
			fi
			_dirsplit "${path%/}"
			path=$_dirsplit_dir
			rest="$_dirsplit_base/$rest"
		done
	)
}


# List the possible names for default*.do files in dir $1 matching the target
# pattern in $2.  We stop searching when we find the first one that exists.
_find_dofiles_pwd()
{
	local dodir="$1" dofile="$2"
	_startswith "$dofile" "default." || dofile=${dofile#*.}
	while :; do
		dofile=default.${dofile#default.*.}
		echo "$dodir$dofile"
		[ -e "$dodir$dofile" ] && return 0
		[ "$dofile" = default.do ] && break
	done
	return 1
}


# List the possible names for default*.do files in $PWD matching the target
# pattern in $1.  We stop searching when we find the first name that works.
# If there are no matches in $PWD, we'll search in .., and so on, to the root.
_find_dofiles()
{
	local target="$1" dodir= dofile= newdir=
	_debug "find_dofile: '$PWD' '$target'"
	dofile="$target.do"
	echo "$dofile"
	[ -e "$dofile" ] && return 0

	# Try default.*.do files, walking up the tree
	_dirsplit "$dofile"
	dodir=$_dirsplit_dir
	dofile=$_dirsplit_base
	[ -n "$dodir" ] && dodir=${dodir%/}/
	[ -e "$dodir$dofile" ] && return 0
	for i in $(_seq 100); do
		[ -n "$dodir" ] && dodir=${dodir%/}/
		#echo "_find_dofiles: '$dodir' '$dofile'" >&2
		_find_dofiles_pwd "$dodir" "$dofile" && return 0
		newdir=$(_realpath "${dodir}.." "$PWD")
		[ "$newdir" = "$dodir" ] && break
		dodir=$newdir
	done
	return 1
}


# Print the last .do file returned by _find_dofiles.
# If that file exists, returns 0, else 1.
_find_dofile()
{
	local files="$(_find_dofiles "$1")"
	rv=$?
	#echo "files='$files'" >&2
	[ "$rv" -ne 0 ] && return $rv
	echo "$files" | {
		while read -r linex; do line=$linex; done
		printf "%s\n" "$line"
	}
}


# Actually run the given $dofile with the arguments in $@.
# Note: you should always run this in a subshell.
_run_dofile()
{
	export DO_DEPTH="$DO_DEPTH  "
	export REDO_TARGET="$PWD/$target"
	local line1
	set -e
	read line1 <"$PWD/$dofile" || true
	cmd=${line1#"#!/"}
	if [ "$cmd" != "$line1" ]; then
		set -$_do_opt_verbose$_do_opt_exec
		exec /$cmd "$PWD/$dofile" "$@"
	else
		set -$_do_opt_verbose$_do_opt_exec
		# If $dofile is empty, "." might not change $? at
		# all, so we clear it first with ":".
		:; . "$PWD/$dofile"
	fi
}


# Find and run the right .do file, starting in dir $1, for target $2,
# providing a temporary output file as $3.  Renames the temp file to $2 when
# done.
_do()
{
	local dir="$1" target="$1$2" tmp="$1$2.redo.tmp" tdir=
	local dopath= dodir= dofile= ext=
	if [ "$_cmd" = "redo" ] ||
	    ( [ ! -e "$target" -o -d "$target" ] &&
	      [ ! -e "$target.did" ] ); then
		printf '%sdo  %s%s%s%s\n' \
			"$green" "$DO_DEPTH" "$bold" "$target" "$plain" >&2
		dopath=$(_find_dofile "$target")
		if [ ! -e "$dopath" ]; then
			echo "do: $target: no .do file ($PWD)" >&2
			return 1
		fi
		_dirsplit "$dopath"
		dodir=$_dirsplit_dir dofile=$_dirsplit_base
		if _startswith "$dofile" "default."; then
			ext=${dofile#default}
			ext=${ext%.do}
		else
			ext=
		fi
		target=$PWD/$target
		tmp=$PWD/$tmp
		cd "$dodir" || return 99
		target=$(_relpath "$target" "$PWD") || return 98
		tmp=$(_relpath "$tmp" "$PWD") || return 97
		base=${target%$ext}
		tdir=$(qdirname "$target")
		[ ! -e "$DO_BUILT" ] || [ ! -w "$tdir/." ] ||
		: >>"$target.did.tmp"
		# $qtmp is a temporary file used to capture stdout.
		# Since it might be accidentally deleted as a .do file
		# does its work, we create it, then open two fds to it,
		# then immediately delete the name.  We use one fd to
		# redirect to stdout, and the other to read from after,
		# because there's no way to fseek(fd, 0) in sh.
		qtmp=$DO_PATH/do.$$.tmp
		(
			rm -f "$qtmp"
			( _run_dofile "$target" "$base" "$tmp" >&3 3>&- 4<&- )
			rv=$?
			if [ $rv != 0 ]; then
				printf "do: %s%s\n" "$DO_DEPTH" \
					"$target: got exit code $rv" >&2
				rm -f "$tmp.tmp" "$tmp.tmp2" "$target.did"
				return $rv
			fi
			echo "$PWD/$target" >>"$DO_BUILT"
			if [ ! -e "$tmp" ]; then
				# if $3 wasn't created, copy from stdout file
				cat <&4 >$tmp
				# if that's zero length too, forget it
				[ -s "$tmp" ] || rm -f "$tmp"
			fi
		) 3>$qtmp 4<$qtmp  # can't use "|| return" here...
		# ...because "|| return" would mess up "set -e" inside the ()
		# on some shells.  Running commands in "||" context, even
		# deep inside, will stop "set -e" from functioning.
		rv=$?
		[ "$rv" = 0 ] || return "$rv"
		mv "$tmp" "$target" 2>/dev/null
		[ -e "$target.did.tmp" ] &&
		mv "$target.did.tmp" "$target.did" ||
		: >>"$target.did"
	else
		_debug "do  $DO_DEPTH$target exists." >&2
	fi
}


# Implementation of the "redo" command.
_redo()
{
	local i startdir="$PWD" dir base
	set +e
	for i in "$@"; do
		i=$(_abspath "$i" "$startdir")
		(
			cd "$DO_STARTDIR" || return 99
			i=$(_realpath "$(_relpath "$i" "$PWD")" "$PWD")
			_dirsplit "$i"
			dir=$_dirsplit_dir base=$_dirsplit_base
			_do "$dir" "$base"
		)
		[ "$?" = 0 ] || return 1
	done
}


# Implementation of the "redo-whichdo" command.
_whichdo()
{
	_find_dofiles "$1"
}


case $_cmd in
	do|redo|redo-ifchange) _redo "$@" ;;
	redo-whichdo) _whichdo "$1" ;;
	do.test) ;;
	*) printf "do: '%s': unexpected redo command" "$_cmd" >&2; exit 99 ;;
esac
[ "$?" = 0 ] || exit 1

if [ -n "$DO_TOP" ]; then
	if [ -n "$_do_opt_clean" ]; then
		echo "do: Removing stamp files..." >&2
		[ ! -e "$DO_BUILT" ] ||
		while read f; do printf "%s.did\0" "$f"; done <"$DO_BUILT" |
		xargs -0 rm -f 2>/dev/null
	fi
fi

M draw.c => draw.c +2 -2
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <errno.h>


@@ 11,7 11,7 @@
#include "util.h"
#include "po.h"
#include "draw.h"
#include "_config.h"
#include "config.h"

/* clang-format off */
static const char* help_title = "Main view help";

M draw.h => draw.h +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <stddef.h>

D install.do => install.do +0 -12
@@ 1,12 0,0 @@
redo-ifchange all
. ./config.redo
install -d "$DOCDIR" "$BINDIR" "${MANPREFIX}/man1"
for docfile in $DOCS; do
	install -Dm 0644 "${docfile}" "${DOCDIR}/${docfile}"
done
for binfile in $PROGS; do
	install -Dm 0755 "${binfile}" "${BINDIR}/${binfile}"
done
for manfile in $MANPAGES; do
	install -Dm 0644 "${manfile}" "${MANPREFIX}/man1/${manfile}"
done

R date.do => lib/makedate +6 -6
@@ 1,3 1,5 @@
#!/bin/sh -x
# vim: set ft=bash:
FALLBACKDATE=${FALLBACKDATE:-unknown}
LC_ALL=C
export LC_ALL


@@ 7,14 9,12 @@ e_user=$(id -un)
if [ -d .git ] && command -v git >/dev/null 2>&1; then
	if [ "$e_user" = "$user" ]; then
		git log --format=format:%cd \
			--date=format:"%B %d, %Y" -1 @ >$3
			--date=format:"%B %d, %Y" -1 @ >date
	else
		su "${user}" -c 'env LC_ALL=C git log --format=format:%cd \
			--date=format:"%B %d, %Y" -1 @' >$3
			--date=format:"%B %d, %Y" -1 @' >date
	fi
	echo >>$3
	echo >>date
else
	printf "%s\n" "$FALLBACKDATE" >$3
	printf "%s\n" "$FALLBACKDATE" >date
fi
redo-always
redo-stamp <$3

R version.do => lib/makeversion +6 -5
@@ 1,3 1,5 @@
#!/bin/sh -x
# vim: set ft=bash:
FALLBACKVER=${FALLBACKVER:-unknown}
LC_ALL=C
export LC_ALL


@@ 6,12 8,11 @@ user=$(unalias ls >/dev/null 2>&1 || true; \
e_user=$(id -un)
if [ -d .git ] && command -v git >/dev/null 2>&1; then
	if [ "$e_user" = "$user" ]; then
		git describe 2>/dev/null | sed 's/^v//' >$3
		git describe 2>/dev/null | sed 's/^v//' >version
	else
		su "${user}" -c 'git describe' 2>/dev/null | sed 's/^v//' >$3
		su "${user}" -c 'git describe' 2>/dev/null |
			sed 's/^v//' >version
	fi
else
	printf "%s\n" "$FALLBACKVER" >$3
	printf "%s\n" "$FALLBACKVER" >version
fi
redo-always
redo-stamp <$3

A lib/mkpack => lib/mkpack +11 -0
@@ 0,0 1,11 @@
#!/bin/sh -x
# vim: set ft=bash:
DISTDIR=sled-$(cat version)
mkdir "$DISTDIR"
for f in $(git ls-files); do
	d="$DISTDIR"/"$(dirname "$f")"
	mkdir -p "$d"
	cp "$f" "$d"/
done
tar -cf - "$DISTDIR" | xz -9v - > "$DISTDIR".tar.xz
rm -fr "$DISTDIR"

A lib/replacepat => lib/replacepat +5 -0
@@ 0,0 1,5 @@
#!/bin/sh -x
# vim: set ft=bash:
DATE=$(cat date)
VERSION=$(cat version)
sed -e 's|%VERSION%|'"$VERSION"'|g' -e 's|%DATE%|'"$DATE"'|g' $1

D pack.do => pack.do +0 -13
@@ 1,13 0,0 @@
redo all
redo-ifchange version
read VERSION <version
VERSION=$(echo $VERSION | sed 's/^v//')
DISTDIR=poe-$VERSION
mkdir $DISTDIR
for f in $(git ls-files); do
	d=$DISTDIR/$(dirname $f)
	mkdir -p $d
	cp $f $d
done 
tar cvf $DISTDIR.tar.xz $DISTDIR >/dev/null
rm -fr $DISTDIR

M po.c => po.c +2 -2
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <libgen.h>


@@ 15,7 15,7 @@
#include "util.h"
#include "po.h"
#include "draw.h"
#include "_config.h"
#include "config.h"

extern const char* errors[];
extern const char* flag_strings[];

M po.h => po.h +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <stdint.h>

M poe.1.in => poe.1.in +1 -1
@@ 47,7 47,7 @@ poe \- .po file editor
.SH COPYRIGHT
.
.LP
poe Copyright \(co 2021\-2023 Strahinya Radich.
poe Copyright \(co 2021\-2024 Strahinya Radich.
.br
This program is licensed under GNU GPL v3 or later.
See the file

M poe.c => poe.c +2 -2
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <errno.h>


@@ 21,7 21,7 @@
#include "util.h"
#include "po.h"
#include "draw.h"
#include "_config.h"
#include "config.h"

extern const char* backup_suffix;
extern const char* errors[];

D poe.do => poe.do +0 -4
@@ 1,4 0,0 @@
redo-ifchange po.o poe.o draw.o util.o
. ./config.redo
${CC} -o $3 po.o poe.o draw.o util.o >/dev/null
${STRIP} $3

D rebuild.do => rebuild.do +0 -1
@@ 1,1 0,0 @@
redo clean all

M termbox.h => termbox.h +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

/*

D uninstall.do => uninstall.do +0 -10
@@ 1,10 0,0 @@
. ./config.redo
for docfile in $DOCS; do
	rm -f "${DOCDIR}/${docfile}"
done
for binfile in $PROGS; do
	rm -f "${BINDIR}/${binfile}"
done
for manfile in $MANPAGES; do
	rm -f "${MANPREFIX}/man1/${manfile}"
done

M util.c => util.c +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <stdarg.h>

M util.h => util.h +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#include <stdint.h>

M version.h.in => version.h.in +1 -1
@@ 1,5 1,5 @@
/* This program is licensed under the terms of GNU GPL v3 or (at your option)
 * any later version. Copyright (C) 2021-2023  Страхиња Радић.
 * any later version. Copyright (C) 2021-2024  Страхиња Радић.
 * See the file LICENSE for exact copyright and license details. */

#define VERSION "%VERSION%"