Makefile

#!/usr/bin/env make
#
# rogomatic - Rog-O-Matic XIV
#
# The following Copyright ONLY applies to this Makefile and README.md files.
#
# Copyright (c) 2025-2026 by Landon Curt Noll.  All Rights Reserved.
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purpose and without fee is hereby granted,
# provided that the above copyright, this permission notice and text
# this comment, and the disclaimer below appear in all of the following:
#
#       supporting documentation
#       source copies
#       source works derived from this source
#       binaries derived from this source or from derived source
#
# LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
# EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
# USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
# chongo (Landon Curt Noll) /\oo/\
#
# http://www.isthe.com/chongo/index.html
# https://github.com/lcn2
#
# Share and enjoy!  :-)


#############
# utilities #
#############

CAT= cat
CC= cc
CHGRP= chgrp
CHMOD= chmod
CLANG_FORMAT= clang-format
CMP= cmp
CODESIGN= codesign
COLCRT= colcrt
CP= cp
CTAGS= ctags
GREP= grep
GROFF= groff
ID= id
INSTALL= install
MAKEDEPEND= makedepend
MKDIR= mkdir
MV= mv
NROFF= nroff
RM= rm
RMDIR= rmdir
SED= sed
SHELL= bash
SORT= sort
TBL= tbl
TOUCH= touch
TRUE= true


#################
# configuration #
#################

PREFIX= /usr/local
BINDIR= ${PREFIX}/bin
SHAREDIR= ${PREFIX}/share
DESTDOC= ${SHAREDIR}/rogomatic
ORIG_DESTDOC= ${DESTDOC}/ORIG_DOC
MANDIR= ${PREFIX}/man
MAN6DIR= ${MANDIR}/man6

# RGMDIR - rogomatic directory
#
# NOTE: RGMDIR will contain logs of Rogomatic's
# scores, an error.log file, and the long term memory file.
# It must be writable by everyone, since score files must be
# created and destroyed by anyone running the program.
#
TMPDIR= /var/tmp
RGMDIR= ${TMPDIR}/rogomatic

# ROGUE - default location of the rogue game
#
# See: https://github.com/lcn2/rogue5.4
#
ROGUE= /usr/local/bin/rogue

# GOODGAME - level at which we always save the gamelog file
#
# NOTE: The -G goodlvl command line option may change the level value.
#
GOODGAME= 23

# USLEEP - Set the default sleep time between actions to USLEEP microseconds
#
# NOTE: The -U usec command line option may change the level value.
#
USLEEP= 14000

# PLUNGE_LVL - Starting level in which we plunge down immediately when we can
#
# NOTE: The plunge mode stops at level 26 because that is where the
#       Amulet of Yendor is found.  DO NOT set PLUNGE larger than 25!
#
# See the plunge() function in tactics.c.
#
# NOTE: Historically PLUNGE_LVL was 18 and was a constant in an if statement:
#
#	  if (Level > 17 && Level < 26 && godownstairs (NOTRUNNING)) {
#
#       By using a lower value, we start to plunge earlier.  We might nit
#       obtain as much gold, but we increase the chance we survive to
#       find the Amulet of Yendor.
#
PLUNGE_LVL= 13

#####################
# debug information #
#####################

# V=@:  do not echo debug statements (quiet mode)
# V=@   echo debug statements (debug / verbose mode)
#
V=@:
#V=@

# Q=@   do not echo internal Makefile actions (quiet mode)
# Q=    echo internal Makefile actions (debug / verbose mode)
#
#Q=
Q=@

# S= >/dev/null 2>&1    silence ${CC} output during hsrc file formation
# S=                    full ${CC} output during hsrc file formation
#
S= >/dev/null 2>&1
#S=

# H=@:	do not report hsrc file formation progress
# H=@	echo hsrc file formation progress
#
#H=@:
H=@


############################
# how to build and install #
############################

CSTD= -std=gnu17
CCWARN=


target=$(shell uname -s 2>/dev/null)
ifeq ($(target),NetBSD)
# The NetBSD maintainers don't define permission bits S_IRUSR et al. in <sys/stat.h>, so NetBSD needs to:
# -D_XOPEN_SOURCE=800		enable permission bits S_IRUSR et al.
# While other systems enable strlcpy, strlcat via <string.h>, NetBSD doesn't, so NetBSD needs to:
# -D_NETBSD_SOURCE		enable strlcpy, strlcat
CPPFLAGS= -D_XOPEN_SOURCE=800 -D_NETBSD_SOURCE
else
CPPFLAGS=
endif

COPT= -O3
DEBUG= -ggdb3

CFLAGS= ${CSTD} ${CCWARN} ${CPPFLAGS} ${COPT} ${DEBUG}

LDFLAGS= ${DEBUG}

LC_CTYPE= C

AT= @

# The NetBSD maintainers insist in using curses instead of ncurses.
# NetBSD uses their own curses: a hybrid of BSD curses and X/Open curses.
# There are known incompatibles between NetBSD curses and what the next of the
# world calls ncurses. See https://wiki.netbsd.org/curses_in_netbsd/
# where not only does the NetBSD maintainers admit to being one of the
# last operating systems (or even the last one?) not using ncurses, and
# where they indicate what is different with ncurses.  One should also
# read: https://www.invisible-island.net/ncurses/ncurses-netbsd.html
# for more info.  Well if you use NetBSD, we hope the NetBSD curses
# works for you.
#
# Alternatively NetBSD users can install the ncurses package for
# NetBSD: https://cdn.netbsd.org/pub/pkgsrc/current/pkgsrc/devel/ncurses/README.html
#
ifeq ($(target),NetBSD)
# Ncurses package installed or use old curses.h?
LIBS!=if test -f /usr/pkg/include/ncurses/ncurses.h; then echo '-lncurses'; else echo '-lcurses'; fi
	ifeq ($(LIBS),-lncurses)
		CPPFLAGS+=-I/usr/pkg/include -I/usr/pkg/include/ncurses
		LDFLAGS+=-L/usr/pkg/lib
	endif
else
LIBS= -lncurses
endif

OTHER_TARGES= titlepage

# targets and local files no longer supported
#
# These files were renamed, so the old name is now obsolete.
#
OBSOLETE_TARGETS= kill_player kill_player.sh run-rogo run-rogo.sh rerun-rogo rerun-rogo.sh

TARGETS= rogomatic player rgmplot histplot gene run_rogo rerun_rogo unstuck_player end_player mrerun_rogo mstop_rogo


################################
# source and destination files #
################################

# we build these .h files during the make
#
BUILD_H_SRC= modern_curses.h have_strlcpy.h have_strlcat.h

H_SRC= config.h getroguetoken.h globals.h install.h strl.h termtokens.h types.h

OBJS= arms.o command.o config.o database.o debug.o debuglog.o explore.o fork_exec.o \
	getroguetoken.o io.o learn.o ltm.o main.o mess.o monsters.o pack.o \
	rand.o replay.o rooms.o terminal.o scorefile.o search.o stats.o strategy.o strl.o \
	survival.o tactics.o things.o timer.o titlepage.o utility.o worth.o

CFILES= arms.c command.c config.c database.c debug.c debuglog.c explore.c fork_exec.c \
	getroguetoken.c io.c learn.c ltm.c main.c mess.c monsters.c pack.c \
	rand.c replay.c rooms.c terminal.c scorefile.c search.c stats.c strategy.c strl.c \
	survival.c tactics.c things.c timer.c titlepage.c utility.c worth.c

MISC_C= setup.c histplot.c rgmplot.c gene.c

C_SRC= ${CFILES} ${MISC_C}

SRC= ${C_SRC} ${H_SRC} ${BUILD_H_SRC}

SH_SRC= run_rogo.sh rerun_rogo.sh unstuck_player.sh end_player.sh mrerun_rogo.sh

SH_TOOL= run_rogo

MISC_OBJS= gene.o histplot.o rgmplot.o setup.o

OTHERS= rplot rgmhist rgmscatter

DOC_SRC= rogomatic.6.in rogomatic.cat.in

# These original documentation files install under the ${ORIG_DESTDOC} directory.
#
ORIG_DOC= ORIG_DOC/amulet.photo ORIG_DOC/Bugreport ORIG_DOC/copyright \
	  ORIG_DOC/knowledge ORIG_DOC/README.0 ORIG_DOC/rnotes ORIG_DOC/rogo.mss \
	  ORIG_DOC/rogomatic.man ORIG_DOC/rogtitle.mss ORIG_DOC/rogue.commands \
	  ORIG_DOC/strike.mss ORIG_DOC/terminfo.vt100 ORIG_DOC/title.ani \
	  ORIG_DOC/title.start ORIG_DOC/titlepage.ani

# These documentation files install under the ${DESTDOC} directory.
#
MISC_DOC= CODE_OF_CONDUCT.md CONTRIBUTING.md COPYING LICENSE README.md SECURITY.md

# File used by macOS to codesign for debugging
#
DEBUG_ENTITLEMENTS= debug.entitlements

MAKE_FILE= Makefile


###################################
# Common Address Sanitizer (ASAN) #
###################################

# Common Address Sanitizer (ASAN)
#
# For more info see: https://github.com/google/sanitizers/wiki/AddressSanitizer
# See also: https://developer.apple.com/documentation/xcode/diagnosing-memory-thread-and-crash-issues-early
# And also: https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
#
# The following Address Sanitizer (ASAN) are common to both RHEL 10.2 (Linux) and macOS 26.5.1.
#
# By default, the Address Sanitizer is NOT enabled.
#
FSANITIZE:= -Wno-invalid-command-line-argument
FSANITIZE+= -fno-common
FSANITIZE+= -fno-omit-frame-pointer
FSANITIZE+= -fsanitize=address
FSANITIZE+= -fsanitize=alignment
FSANITIZE+= -fsanitize=bool
FSANITIZE+= -fsanitize=bounds
FSANITIZE+= -fsanitize=enum
FSANITIZE+= -fsanitize=float-cast-overflow
FSANITIZE+= -fsanitize=float-divide-by-zero
FSANITIZE+= -fsanitize=integer-divide-by-zero
FSANITIZE+= -fsanitize=nonnull-attribute
FSANITIZE+= -fsanitize=null
FSANITIZE+= -fsanitize=object-size
FSANITIZE+= -fsanitize=returns-nonnull-attribute
FSANITIZE+= -fsanitize=shift
FSANITIZE+= -fsanitize=signed-integer-overflow
FSANITIZE+= -fsanitize=undefined
FSANITIZE+= -fsanitize=unreachable
FSANITIZE+= -fsanitize=vla-bound
FSANITIZE+= -fsanitize=vptr

# Address Sanitizer (ASAN) options for macOS
#
MACOS_FSANITIZE+= -fsanitize=nullability-arg
MACOS_FSANITIZE+= -fsanitize=nullability-assign
MACOS_FSANITIZE+= -fsanitize=nullability-return
MACOS_FSANITIZE+= -fstack-protector-all

# Address Sanitizer (ASAN) options for Linux
#
LINUX_FSANITIZE+= -fstack-protector-all

# Guess at Address Sanitizer (ASAN) options for non-macOS non-Linux
#
OTHER_FSANITIZE+= -fstack-protector-all

####
# macOS Address Sanitizer (ASAN)
#
# This comment block was tested under:
#
#       macOS 27.0 with Apple clang version 21.0.0 (clang-2100.3.34.2)
#
#       See: https://developer.apple.com/documentation/xcode/diagnosing-memory-thread-and-crash-issues-early
#
# To use the Address Sanitizer, uncomment this set set of lines and recompile (make clobber all):
#
# For more info see: https://github.com/google/sanitizers/wiki/AddressSanitizer
#
# And also: https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
#
# For Homebrew gcc version 16 only:
#
# CC:= gcc-16
# DEBUG:= -g2
#
# For Apple clang and Homebrew gcc:
#
# CCWARN+= -Wall
# CCWARN+= -pedantic
# CCWARN+= -Werror
# COPT:= -O0
#
# For Apple clang only:
#
# FSANITIZE+= -fsanitize=nullability-arg
# FSANITIZE+= -fsanitize=nullability-assign
# FSANITIZE+= -fsanitize=nullability-return
#
# CFLAGS+= ${FSANITIZE} -fstack-protector-all
# LDFLAGS+= ${FSANITIZE}
# DEBUG:= -ggdb3
####

####
# RHEL (Linux) Address Sanitizer (ASAN)
#
# This comment block was tested under:
#
#       RHEL 10.2 with clang version 21.1.8 (Red Hat, Inc. 21.1.8-1.el10)
#
# with these RPMs installed:
#
#       libasan-14.3.1-4.4.el10.x86_64
#       libubsan-14.3.1-4.4.el10.x86_64
#
# To use the Address Sanitizer, uncomment this set set of lines and recompile (make clobber all):
#
# For more info see: https://github.com/google/sanitizers/wiki/AddressSanitizer
#
# And also: https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
#
# Be sure you have the following dnf packages installed:
#
#   dnf install readline-devel ncurses-libs ncurses-devel libasan libubsan
#
# CCWARN+= -Wall
# CCWARN+= -pedantic
# CCWARN+= -Werror
# COPT:= -O0
#
# CFLAGS+= ${FSANITIZE} -fstack-protector-all
# LDFLAGS+= ${FSANITIZE}
# DEBUG:= -ggdb3
####


######################################
# all - default rule - must be first #
######################################

all: ${BUILD_H_SRC} ${TARGETS} rogomatic.6


#####################################
# object files with special defines #
#####################################

config.o: config.c
	${CC} ${CFLAGS} -DUSLEEP=${USLEEP} -DGOODGAME=${GOODGAME} -DRGMDIR='"${RGMDIR}"' $< -c

setup.o: setup.c
	${CC} ${CFLAGS} -DUSLEEP=${USLEEP} -DGOODGAME=${GOODGAME} -DROGUE='"${ROGUE}"' -DRGMDIR='"${RGMDIR}"' $< -c

strategy.o: strategy.c
	${CC} ${CFLAGS} -DPLUNGE_LVL=${PLUNGE_LVL} $< -c

tactics.o: tactics.c
	${CC} ${CFLAGS} -DPLUNGE_LVL=${PLUNGE_LVL} $< -c

terminal.o: terminal.c
	${CC} ${CFLAGS} -DRGMDIR='"${RGMDIR}"' $< -c

utility.o: utility.c
	${CC} ${CFLAGS} -DRGMDIR='"${RGMDIR}"' $< -c


########################
# default object files #
########################

.c.o:
	${CC} ${CFLAGS} -c $*.c


##################
# tools to build #
##################

gene: gene.o rand.o learn.o stats.o timer.o utility.o config.o strl.o terminal.o
	${CC} ${CFLAGS} ${LDFLAGS} gene.o rand.o learn.o stats.o timer.o utility.o config.o strl.o terminal.o -lm ${LIBS} -o $@

histplot: histplot.o timer.o utility.o strl.o config.o terminal.o
	${CC} ${LDFLAGS} histplot.o timer.o utility.o strl.o config.o terminal.o ${LIBS} -o $@

player: ${OBJS}
	${CC} ${LDFLAGS} ${OBJS} -lm ${LIBS} -o $@
ifeq ($(target),Darwin)
	${CODESIGN} -s - -f --entitlements ${DEBUG_ENTITLEMENTS} $@
endif

rgmplot: rgmplot.o timer.o utility.o strl.o config.o terminal.o
	${CC} ${LDFLAGS} rgmplot.o timer.o utility.o strl.o config.o terminal.o ${LIBS} -o $@

rogomatic: setup.o scorefile.o timer.o utility.o config.o strl.o terminal.o fork_exec.o
	${CC} ${LDFLAGS} setup.o scorefile.o timer.o utility.o config.o strl.o terminal.o fork_exec.o ${LIBS} -o $@
ifeq ($(target),Darwin)
	${CODESIGN} -s - -f --entitlements ${DEBUG_ENTITLEMENTS} $@
endif

run_rogo: run_rogo.sh
	${CP} -f run_rogo.sh $@
	${CHMOD} +x $@

rerun_rogo: rerun_rogo.sh
	${CP} -f rerun_rogo.sh $@
	${CHMOD} +x $@

mrerun_rogo: mrerun_rogo.sh
	${CP} -f mrerun_rogo.sh $@
	${CHMOD} +x $@

unstuck_player: unstuck_player.sh
	${CP} -f unstuck_player.sh $@
	${CHMOD} +x $@

end_player: end_player.sh
	${CP} -f end_player.sh $@
	${CHMOD} +x $@

mstop_rogo: mstop_rogo.sh
	${CP} -f mstop_rogo.sh $@
	${CHMOD} +x $@


##################################################
# other targets that are not automatically built #
##################################################

# NOTE: This rule is NOT part of the build of rogomatic documentation!
#	We use this rule to form the rogomatic.cat.in file from the rogomatic.6.in file.
#
form_rogomatic_cat_in: rogomatic.6.in
	${RM} -f rogomatic.cat.in
	${GROFF} -Tascii -man rogomatic.6.in | LC_CTYPE=C ${SED} -e 's/.\x08//g' > rogomatic.cat.in

# reformat primary (non-built) source using clang-format
#
clang-format: .clang-format ${C_SRC} ${H_SRC}
	${CLANG_FORMAT} -i --style=file:.clang-format ${C_SRC} ${H_SRC}

# try to compile all with gcc, full warnings, no optimizer, no ASAN
#
# NOTE: Consider doing a "make clobber" first, especially when switching from a previous "make all", "make clang", etc.
#
# NOTE: On some systems with clang installed (i.e., macOS / Darwin), the clang package installs a gcc executable that
#       acts like a front end translating gcc args into clang args.  In such cases, gcc is just clang,
#       and so if we "make gcc" in that case, the final result is really just did "make clang": not what we want.
#       If someone has called "make gcc", we presume that their intention is to use gcc, not clang.
#       Where clang is primary, and gcc is just an arg front end to clang, it is possible to install gcc
#       as a separate package.  On such true dual compiler systems, where gcc has been explicitly installed
#       as a separate compiler, a gcc-digits binary is also installed; "digits" is the major version of gcc.
#
#       For macOS (Darwin) systems, if someone invokes "make gcc", we avoid the mistake of using the gcc
#       front end to clang by mistake.  Thus, on macOS, for "make gcc" to work properly and compile with
#       the gcc compiler, we will require that the system have explicitly installed gcc, and to invoke it
#       in the gcc-digits binary form.  Nevertheless, we realize that this ties the "make gcc" rule for
#       such systems to an explicit major version of gcc.  And there are GOOD REASONS to do this:
#
#               The sad state of the gcc debugger, gdb, is such that it has become, in our opinion,
#               a second-rate debugger.  We won't go into much detail here other than to say that it
#               is "not fun" to try to debug with gdb, a binary that uses ncurses (or curses) to control the
#               terminal (e.g., rogue), and it is "not fun" to debug with gdb, a binary that will "fork/exec"
#               something (e.g., rogomatic).
#
#               The gcc compiler release process is described by some as "mood swings", with significant
#               and sometimes non-trivial changes to behaviour.  Therefore, we tie the "make gcc" make rule
#               to an explicit major version of gcc, and ONLY update the "make gcc" rule when we have
#               fully tested the result under the next major version of gcc.
#
#       Remember that the reason why we have "make gcc" (and "make clang") is to compile in such a way as to
#       make debugging more effective.  If you do not intend to compile for debugging purposes, just use "make all"
#       and explicitly set the compiler you want:
#
#               make all CC='/path/to/cc'
#
#       What should you do if you don't like the way "make gcc" operates?  We recommend just using "make all"
#       with explicit make variable settings on the command line.  For example, say you are on a macOS (Darwin)
#       system where "make gcc" calls gcc-16 and you want to instead call gcc-17, then try:
#
#               make all CC='gcc-17' CCWARN='-Wall -pedantic -Werror' COPT='-O0' DEBUG='-g2'
#
#       Or say you are on some other system where both clang and gcc are installed, and that the gcc executable
#       isn't a clang front end (be SURE this is the case, and that due to the order you installed clang and gcc,
#       or due to your $PATH value that gcc isn't just an arg converting front end for clang!).  Then try:
#
#               make all CC='/path/to/gcc' CCWARN='-Wall -pedantic -Werror' COPT='-O0' DEBUG='-g2'
#
#       So where does all these comments leave us?
#
#               The "make gcc" rule is intended for debugging, and we do NOT recommend debugging code with gdb.
#               So these may not be the compiler droids you are looking for.  :-)
#
#               The Darwin target value of CC in "make gcc" below is the current major version of gcc that
#               we have attempted to support.  You are on your own if you wish to use a different major version.
#
#               See the above comments for make line workarounds if you need them.
#
gcc:
ifeq ($(target),Darwin)
	${MAKE} -f ${MAKE_FILE} all CC='gcc-16' CCWARN='-Wall -pedantic -Werror' COPT='-O0' DEBUG='-g2'
else
	${MAKE} -f ${MAKE_FILE} all CC='gcc' CCWARN='-Wall -pedantic -Werror' COPT='-O0' DEBUG='-ggdb3'
endif

# compile all with clang, full warnings, no optimizer, no ASAN
#
# NOTE: Consider doing a "make clobber" first, especially when switching from a previous "make all", "make gcc", etc.
#
clang:
	${MAKE} -f ${MAKE_FILE} all CC='clang' CCWARN='-Wall -Wno-char-subscripts -pedantic -Werror' COPT='-O0' DEBUG='-ggdb3'

# compile all with Address Sanitizer (ASAN) enabled
#
# If macOS (Darwin), set Address Sanitizer (ASAN) values for compiling and linking.
# See the "macOS Address Sanitizer (ASAN)" section above for details.
#
# If Linux, set Address Sanitizer (ASAN) values for compiling and linking.
# See the "RHEL (Linux) Address Sanitizer (ASAN)" section above for details.
#
# On all non-macOS non-Linux environments, make a best guess on (ASAN) values for compiling and linking.
#
# NOTE: Consider doing a "make clobber" first, especially when switching from a previous "make all", "make clang", etc.
#
# Suggestion:
#
#	make clobber asan
#	rm -f asan.log.* ; ASAN_OPTIONS="log_path=asan.log" ./rogomatic ; reset ; cat asan.log.*
#
asan:
ifeq ($(target),Darwin)
	${MAKE} -f ${MAKE_FILE} all CC='clang' CCWARN='-Wall -Wno-char-subscripts -pedantic -Werror' COPT='-O0' \
				    DEBUG='-ggdb3 ${FSANITIZE} ${MACOS_FSANITIZE}'
else
ifeq ($(target),Linux)
	${MAKE} -f ${MAKE_FILE} all CC='gcc' CCWARN='-Wall -Wno-char-subscripts -pedantic -Werror' COPT='-O0' \
				    DEBUG='-ggdb3 ${FSANITIZE} ${LINUX_FSANITIZE}'
else
	${MAKE} -f ${MAKE_FILE} all CC='gcc' CCWARN='-Wall -Wno-char-subscripts -pedantic -Werror' COPT='-O0' \
				    DEBUG='-ggdb3 ${FSANITIZE} ${OTHER_FSANITIZE}'
endif
endif

# titlepage - test the title page
#
titlepage: titlepage.c
	${CC} titlepage.c -DTITLEPAGE_MAIN ${LIBS} -o titlepage


#####################
# constricted files #
#####################

hsrc: ${BUILD_H_SRC}

# NOTE: The modern_curses.h file doesn't need these make variables, we simply test them here as a convenience.
#
modern_curses.h: ${MAKE_FILE}
	${Q} ${RM} -f modern_curses.o modern_curses $@
	${H} echo 'forming $@'
	${Q} echo '/*' > $@
	${Q} echo ' * DO NOT EDIT -- generated by the Makefile rule $@' >> $@
	${Q} echo ' */' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#if !defined(INCLUDE_MODERN_CURSES_H)' >> $@
	${Q} echo '#define INCLUDE_MODERN_CURSES_H' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '/* do have modern new curses ? */' >> $@
	-${Q} if echo '#include <ncurses.h>' | ${CC} -E ${CPPFLAGS} - ${S}; then \
	    echo '#include <ncurses.h> /* yes, using new curses */' >> $@; \
	    echo >> $@; \
	    echo '#define MODERN_CURSES NEW_CURSES' >> $@; \
	elif echo '#include <curses.h>' | ${CC} -E ${CPPFLAGS} - ${S}; then \
	    echo '#include <curses.h> /* no, you have old curses, or what NetBSD calls curses */' >> $@; \
	    echo >> $@; \
	    echo '#define MODERN_CURSES OLD_CURSES' >> $@; \
	else \
	    echo 'Neither <ncurses.h> nor <curses.h> found' 1>&2; \
	    echo 'Perhaps you need you install both ncurses and ncurses-devel ?' 1>&2; \
	    exit 1; \
	fi
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#endif' >> $@
	${H} echo '$@ formed'
	-${Q}if [ -z "${Q}" ]; then \
	    echo ''; \
	    echo '=-=-= start of $@ =-=-='; \
	    ${CAT} $@; \
	    echo '=-=-= end of $@ =-=-='; \
	    echo ''; \
	else \
	    ${TRUE}; \
	fi

have_strlcpy.h: have_strlcpy.c ${MAKE_FILE}
	${Q} ${RM} -f unused_tmp $@
	${H} echo 'forming $@'
	${Q} echo '/*' > $@
	${Q} echo ' * DO NOT EDIT -- generated by the Makefile rule $@' >> $@
	${Q} echo ' */' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#if !defined(INCLUDE_STRLCPY_H)' >> $@
	${Q} echo '#define INCLUDE_STRLCPY_H' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '/* do we have the strlcpy() function? */' >> $@
	${Q} ${RM} -f have_strlcpy.o have_strlcpy
	-${Q} ${CC} have_strlcpy.c -c ${S} \
		|| ${TRUE}
	-${Q} ${CC} have_strlcpy.o -o have_strlcpy ${S} \
		|| ${TRUE}
	-${Q} ./have_strlcpy > unused_tmp ${E} \
		|| ${TRUE}
	-${Q} if [ -s unused_tmp ]; then \
	    ${CAT} unused_tmp >> $@; \
	else \
	    echo '#undef INCLUDE_STRLCPY /* no - use code from strl.c */' \
	         >> $@; \
	fi
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#endif' >> $@
	${Q} ${RM} -f have_strlcpy have_strlcpy.o unused_tmp
	${H} echo '$@ formed'
	-${Q}if [ -z "${Q}" ]; then \
	    echo ''; \
	    echo '=-=-= start of $@ =-=-='; \
	    ${CAT} $@; \
	    echo '=-=-= end of $@ =-=-='; \
	    echo ''; \
	else \
	    ${TRUE}; \
	fi

have_strlcat.h: have_strlcat.c ${MAKE_FILE}
	${Q} ${RM} -f unused_tmp $@
	${H} echo 'forming $@'
	${Q} echo '/*' > $@
	${Q} echo ' * DO NOT EDIT -- generated by the Makefile rule $@' >> $@
	${Q} echo ' */' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#if !defined(INCLUDE_STRLCAT_H)' >> $@
	${Q} echo '#define INCLUDE_STRLCAT_H' >> $@
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '/* do we have the strlcat() function? */' >> $@
	${Q} ${RM} -f have_strlcat.o have_strlcat
	-${Q} ${CC} have_strlcat.c -c ${S} \
		|| ${TRUE}
	-${Q} ${CC} have_strlcat.o -o have_strlcat ${S} \
		|| ${TRUE}
	-${Q} ./have_strlcat > unused_tmp ${E} \
		|| ${TRUE}
	-${Q} if [ -s unused_tmp ]; then \
	    ${CAT} unused_tmp >> $@; \
	else \
	    echo '#undef INCLUDE_STRLCAT /* no - use code from strl.c */' \
	         >> $@; \
	fi
	${Q} echo '' >> $@
	${Q} echo '' >> $@
	${Q} echo '#endif' >> $@
	${Q} ${RM} -f have_strlcat have_strlcat.o unused_tmp
	${H} echo '$@ formed'
	-${Q}if [ -z "${Q}" ]; then \
	    echo ''; \
	    echo '=-=-= start of $@ =-=-='; \
	    ${CAT} $@; \
	    echo '=-=-= end of $@ =-=-='; \
	    echo ''; \
	else \
	    ${TRUE}; \
	fi


################################
# form rogomatic documentation #
################################

stddocs: rogomatic.6 rogomatic.cat

rogomatic.6: rogomatic.6.in
	${RM} -f $@
	LC_CTYPE=C ${SED} -e 's;${AT}RGMDIR${AT};${RGMDIR};' \
			  -e 's;${AT}BINDIR${AT};${BINDIR};' \
			  -e 's;${AT}GOODGAME${AT};${GOODGAME};' \
			  -e 's;${AT}USLEEP${AT};${USLEEP};' \
			  rogomatic.6.in > rogomatic.6

rogomatic.cat: rogomatic.6 rogomatic.cat.in
	${RM} -f $@
	@-if test "x${GROFF}" != "x" -a "x${SED}" != "x" ; then \
	    echo "${GROFF} -Tascii -man rogomatic.6 | LC_CTYPE=C ${SED} -e 's/.\x08//g' > $@" ; \
	    ${GROFF} -Tascii -man rogomatic.6 | LC_CTYPE=C ${SED} -e 's/.\x08//g' > $@ ; \
	elif test "x${NROFF}" != "x" -a "x${TBL}" != "x" -a "x${COLCRT}" != "x" ; then \
	    echo "${NROFF} -man rogomatic.6 | ${COLCRT} - > $@" ; \
	    ${NROFF} -man rogomatic.6 | ${COLCRT} - > $@ ; \
        else \
	    echo "LC_CTYPE=C ${SED} \
			      -e 's;${AT}RGMDIR${AT};${RGMDIR};' \
			      -e 's;${AT}BINDIR${AT};${BINDIR};' \
			      -e 's;${AT}GOODGAME${AT};${GOODGAME};' \
			      -e 's;${AT}USLEEP${AT};${USLEEP};' \
			      rogomatic.cat.in > $@" ; \
	    LC_CTYPE=C ${SED} \
			      -e 's;${AT}RGMDIR${AT};${RGMDIR};' \
			      -e 's;${AT}BINDIR${AT};${BINDIR};' \
			      -e 's;${AT}GOODGAME${AT};${GOODGAME};' \
			      -e 's;${AT}USLEEP${AT};${USLEEP};' \
			      rogomatic.cat.in > $@ ; \
	fi


#################################################
# .PHONY list of rules that do not create files #
#################################################

.PHONY: all stddocs clean clobber install \
	backup clashes dist fluff print titler words \
	index depend


###################################
# standard Makefile utility rules #
###################################

legacy_clean:
	${Q}${RM} -f datesub.o tf.o findscore.o

legacy_clobber:
	${Q}${RM} -f datesub datesub.l tf

clean: legacy_clean
	${RM} -f ${MISC_OBJS}
	${RM} -f ${OBJS}

clobber: legacy_clobber clean
	${RM} -f tags index rogomatic.6 rogomatic.cat
	${RM} -f ${OTHER_TARGES}
	${RM} -f ${TARGETS}
	${RM} -f ${BUILD_H_SRC}
	${RM} -rf *.dSYM
	-@for i in ${OBSOLETE_TARGETS}; do \
	    if [[ -e $$i ]]; then \
	        echo "${RM} -f $$i" ; \
	        ${RM} -f "$$i" ; \
	    fi; \
	done

install: all ${MISC_DOC} ${ORIG_DOC} stddocs
	${INSTALL} -d -m 0755 ${BINDIR}
	${INSTALL} -m 0755 ${TARGETS} ${BINDIR}
ifeq ($(target),Darwin)
	${CODESIGN} -s - -f --entitlements ${DEBUG_ENTITLEMENTS} ${BINDIR}/rogomatic ${BINDIR}/player
endif
	${INSTALL} -d -m 1777 ${TMPDIR}
	${INSTALL} -d -m 1777 ${RGMDIR}
	${INSTALL} -d -m 0755 ${SHAREDIR}
	${INSTALL} -d -m 0755 ${DESTDOC}
	${INSTALL} -m 0444 ${MISC_DOC} ${DESTDOC}
	${INSTALL} -d -m 0755 ${ORIG_DESTDOC}
	${INSTALL} -m 0444 ${ORIG_DOC} ${ORIG_DESTDOC}
	${INSTALL} -d -m 0755 ${MANDIR}
	${INSTALL} -d -m 0755 ${MAN6DIR}
	${INSTALL} -m 0444 rogomatic.6 ${MAN6DIR}
	-@for i in ${OBSOLETE_TARGETS} run_rogo.sh; do \
	    if [[ -e ${BINDIR}/$$i ]]; then \
		echo "removing obsolete: ${BINDIR}/$$i" ; \
	        ${RM} -f -v "${BINDIR}/$$i" ; \
	    fi; \
	done

uninstall:
	-@for i in ${TARGETS}; do \
	    echo "${RM} -f -v ${BINDIR}/$$i"; \
	    ${RM} -f -v ${BINDIR}/$$i; \
	done
	-@for i in ${MISC_DOC} ${ORIG_DOC}; do \
	    echo "${RM} -f -v ${DESTDOC}/$$i"; \
	    ${RM} -f -v ${DESTDOC}/$$i; \
	done
	-${RM} -f -v ${MAN6DIR}/rogomatic.6
	-@if [[ -d "${RGMDIR}" ]]; then \
	    echo "${RMDIR} ${RGMDIR} 2>/dev/null"; \
	    ${RMDIR} ${RGMDIR} 2>/dev/null; \
	fi
	-@if [[ -d "${RGMDIR}" ]]; then \
	    echo "You may wish to: rm -rf ${RGMDIR}"; \
	fi
	-@if [[ -d "${ORIG_DESTDOC}" ]]; then \
	    echo "${RMDIR} ${ORIG_DESTDOC} 2>/dev/null"; \
	    ${RMDIR} ${ORIG_DESTDOC} 2>/dev/null; \
	fi
	-@if [[ -d "${ORIG_DESTDOC}" ]]; then \
	    echo "You may wish to: rm -rf ${ORIG_DESTDOC}"; \
	fi
	-@if [[ -d "${DESTDOC}" ]]; then \
	    echo "${RMDIR} ${DESTDOC} 2>/dev/null"; \
	    ${RMDIR} ${DESTDOC} 2>/dev/null; \
	fi
	-@if [[ -d "${DESTDOC}" ]]; then \
	    echo "You may wish to: rm -rf ${DESTDOC}"; \
	fi
	-@for i in ${OBSOLETE_TARGETS} run_rogo.sh; do \
	    if [[ -e ${BINDIR}/$$i ]]; then \
		echo "removing obsolete: ${BINDIR}/$$i" ; \
	        ${RM} -f -v "${BINDIR}/$$i" ; \
	    fi; \
	done

index: ${CFILES}
	${RM} -f index
	${CTAGS} -x ${C_SRC} > index

tags: ${SRC}
	${CTAGS} -w ${SRC}


###############################
# easy backward compatibility #
###############################

# These rules were referenced in the makefile of 2022 Nov 17
#
# We no longer support these rules.
#
# We provide these stub rules for backward compatibility.

backup:
	@echo dist rule disabled, use the GitHub repo: https://github.com/lcn2/rogomatic

clashes:
	@echo $@ disabled

dist:
	@echo dist rule disabled, use the GitHub repo: https://github.com/lcn2/rogomatic

fluff:
	@echo $@ disabled

print:
	@echo $@ disabled

titler:
	@echo $@ disabled

words:
	@echo $@ disabled


####################
# dependency rules #
####################

###
#
# Home grown make dependency rules.  Your system may not support
# or have the needed tools.  You can ignore this section.
#
# We will form a skeleton tree of *.c files containing only #include "foo.h"
# lines and .h files containing the same lines surrounded by multiple include
# prevention lines.  This allows us to build a static depend list that will
# satisfy all possible cpp symbol definition combinations.
#
###

depend: ${SRC}
	${Q} if [ -f ${MAKE_FILE}.bak ]; then \
	    echo "${MAKE_FILE}.bak exists, remove or move it"; \
	    exit 1; \
	else \
	    ${TRUE}; \
	fi
	${Q} if type -f ${MAKEDEPEND}; then \
	    ${TRUE}; \
	else \
	    echo "make depend failed: cannot find makedepend command: ${MAKEDEPEND}" 1>&2; \
	    exit 1; \
	fi
	${Q} ${RM} -rf skel
	${Q} ${MKDIR} -p skel
	-${Q} for i in ${C_SRC}; do \
	    ${SED} -n '/^#[	 ]*include[	 ]*"/p' "$$i" > "skel/$$i"; \
	done
	${Q} ${MKDIR} -p skel/custom
	-${Q} for i in ${H_SRC} ${BUILD_H_SRC} /dev/null; do \
	    if [ X"$$i" != X"/dev/null" ]; then \
		tag="`echo $$i | ${SED} 's/[\.+,:]/_/g'`"; \
		echo "#if !defined($$tag)" > "skel/$$i"; \
		echo "#define $$tag" >> "skel/$$i"; \
		${SED} -n '/^#[	 ]*include[	 ]*"/p' "$$i" | \
		    LANG=C ${SORT} -u >> "skel/$$i"; \
		echo '#endif /* '"$$tag"' */' >> "skel/$$i"; \
	    fi; \
	done
	${Q} ${RM} -f skel/makedep.out
	${Q} echo top level skel formed
	${Q} echo forming dependency list
	${Q} :> skel/makedep.out
	${Q} cd skel; ${MAKEDEPEND} \
	    -w 1 -f makedep.out -- \
	    ${CFLAGS} -- \
	    ${SRC} 2>/dev/null
	-${Q} for i in ${C_SRC} /dev/null; do \
	    if [ X"$$i" != X"/dev/null" ]; then \
	      echo "$$i" | ${SED} 's/^\(.*\)\.c/\1.o: \1.c/'; \
	    fi; \
	done >> skel/makedep.out
	${Q} LANG=C ${SORT} -u skel/makedep.out -o skel/makedep.out
	${Q} echo dependency list formed
	${Q} echo forming new ${MAKE_FILE}
	${Q} ${RM} -f ${MAKE_FILE}.bak
	${Q} ${MV} ${MAKE_FILE} ${MAKE_FILE}.bak
	${Q} ${SED} -n '1,/^# DO NOT DELETE THIS LINE/p' \
		    ${MAKE_FILE}.bak > ${MAKE_FILE}
	${Q} ${GREP} -E -v '^#' skel/makedep.out >> ${MAKE_FILE}
	${Q} echo removing top level skel
	${Q} ${RM} -rf skel
	-${Q} if ${CMP} -s ${MAKE_FILE}.bak ${MAKE_FILE}; then \
	    echo 'top level ${MAKE_FILE} was already up to date'; \
	    echo 'restoring original ${MAKE_FILE}'; \
	    ${MV} -f ${MAKE_FILE}.bak ${MAKE_FILE}; \
	else \
	    echo 'old ${MAKE_FILE} is now ${MAKE_FILE}.bak'; \
	    echo 'new top level ${MAKE_FILE} formed'; \
	    echo 'try: diff -u ${MAKE_FILE}.bak ${MAKE_FILE}'; \
	fi

###
#
# make depend stuff
#
###

# DO NOT DELETE THIS LINE -- make depend depends on it.

arms.o: arms.c
arms.o: globals.h
arms.o: modern_curses.h
arms.o: types.h
command.o: command.c
command.o: config.h
command.o: globals.h
command.o: have_strlcat.h
command.o: have_strlcpy.h
command.o: modern_curses.h
command.o: strl.h
command.o: types.h
config.o: config.c
config.o: config.h
config.o: have_strlcat.h
config.o: have_strlcpy.h
config.o: strl.h
config.o: types.h
database.o: database.c
database.o: globals.h
database.o: have_strlcat.h
database.o: have_strlcpy.h
database.o: modern_curses.h
database.o: strl.h
database.o: types.h
debug.o: config.h
debug.o: debug.c
debug.o: globals.h
debug.o: have_strlcat.h
debug.o: have_strlcpy.h
debug.o: install.h
debug.o: modern_curses.h
debug.o: strl.h
debug.o: types.h
debuglog.o: config.h
debuglog.o: debuglog.c
debuglog.o: globals.h
debuglog.o: types.h
explore.o: config.h
explore.o: explore.c
explore.o: globals.h
explore.o: modern_curses.h
explore.o: types.h
fork_exec.o: config.h
fork_exec.o: fork_exec.c
fork_exec.o: types.h
gene.o: config.h
gene.o: gene.c
gene.o: install.h
gene.o: types.h
getroguetoken.o: config.h
getroguetoken.o: getroguetoken.c
getroguetoken.o: globals.h
getroguetoken.o: termtokens.h
getroguetoken.o: types.h
histplot.o: have_strlcat.h
histplot.o: have_strlcpy.h
histplot.o: histplot.c
histplot.o: strl.h
histplot.o: types.h
io.o: config.h
io.o: getroguetoken.h
io.o: globals.h
io.o: have_strlcat.h
io.o: have_strlcpy.h
io.o: install.h
io.o: io.c
io.o: modern_curses.h
io.o: strl.h
io.o: termtokens.h
io.o: types.h
learn.o: config.h
learn.o: learn.c
learn.o: types.h
ltm.o: config.h
ltm.o: globals.h
ltm.o: have_strlcat.h
ltm.o: have_strlcpy.h
ltm.o: install.h
ltm.o: ltm.c
ltm.o: modern_curses.h
ltm.o: strl.h
ltm.o: types.h
main.o: config.h
main.o: have_strlcat.h
main.o: have_strlcpy.h
main.o: install.h
main.o: main.c
main.o: modern_curses.h
main.o: strl.h
main.o: termtokens.h
main.o: types.h
mess.o: config.h
mess.o: globals.h
mess.o: have_strlcat.h
mess.o: have_strlcpy.h
mess.o: mess.c
mess.o: modern_curses.h
mess.o: strl.h
mess.o: types.h
monsters.o: config.h
monsters.o: globals.h
monsters.o: modern_curses.h
monsters.o: monsters.c
monsters.o: types.h
pack.o: config.h
pack.o: globals.h
pack.o: have_strlcat.h
pack.o: have_strlcpy.h
pack.o: modern_curses.h
pack.o: pack.c
pack.o: strl.h
pack.o: types.h
rand.o: rand.c
replay.o: globals.h
replay.o: modern_curses.h
replay.o: replay.c
replay.o: types.h
rgmplot.o: have_strlcat.h
rgmplot.o: have_strlcpy.h
rgmplot.o: rgmplot.c
rgmplot.o: strl.h
rgmplot.o: types.h
rooms.o: config.h
rooms.o: globals.h
rooms.o: modern_curses.h
rooms.o: rooms.c
rooms.o: types.h
scorefile.o: config.h
scorefile.o: globals.h
scorefile.o: install.h
scorefile.o: scorefile.c
scorefile.o: types.h
search.o: config.h
search.o: globals.h
search.o: modern_curses.h
search.o: search.c
search.o: types.h
setup.o: config.h
setup.o: have_strlcat.h
setup.o: have_strlcpy.h
setup.o: install.h
setup.o: setup.c
setup.o: strl.h
setup.o: types.h
stats.o: stats.c
stats.o: types.h
strategy.o: config.h
strategy.o: globals.h
strategy.o: install.h
strategy.o: modern_curses.h
strategy.o: strategy.c
strategy.o: types.h
strl.o: have_strlcat.h
strl.o: have_strlcpy.h
strl.o: strl.c
strl.o: strl.h
survival.o: config.h
survival.o: globals.h
survival.o: modern_curses.h
survival.o: survival.c
survival.o: types.h
tactics.o: config.h
tactics.o: globals.h
tactics.o: install.h
tactics.o: modern_curses.h
tactics.o: tactics.c
tactics.o: types.h
terminal.o: config.h
terminal.o: globals.h
terminal.o: terminal.c
terminal.o: types.h
things.o: config.h
things.o: globals.h
things.o: modern_curses.h
things.o: things.c
things.o: types.h
timer.o: config.h
timer.o: globals.h
timer.o: timer.c
timer.o: types.h
titlepage.o: globals.h
titlepage.o: modern_curses.h
titlepage.o: titlepage.c
titlepage.o: types.h
utility.o: have_strlcat.h
utility.o: have_strlcpy.h
utility.o: install.h
utility.o: modern_curses.h
utility.o: strl.h
utility.o: types.h
utility.o: utility.c
worth.o: globals.h
worth.o: modern_curses.h
worth.o: types.h
worth.o: worth.c