--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/seqrequester/src/Makefile	Sat Jul 13 12:39:06 2024 +0000
@@ -0,0 +1,465 @@
+# -*- Makefile -*-
+#
+# boilermake: A reusable, but flexible, boilerplate Makefile.
+#
+# Copyright 2008, 2009, 2010 Dan Moulding, Alan T. DeKok
+#
+# 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 Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#
+# Significantly modified for Marbl projects.  Get the original from
+#   https://github.com/dmoulding/boilermake
+#
+
+include Makefile.boilermake
+
+#
+#  Check that Make and git are compatible, fail if not.
+#
+
+define TEST_VERSION
+  path   := $$(shell which ${1})
+  vers   := $$(shell ${1}     --version | head -n 1 | cut -d\  -f ${2})
+  versn  := $$(shell echo $${vers} | sed -e 's/\.\([0-9][0-9]\)/\1/g' -e 's/\.\([0-9]\)/0\1/g' -e 's/^[0-9]\{3,4\}$$$$/&00/')
+  min    := $$(shell echo ${3}     | sed -e 's/\.\([0-9][0-9]\)/\1/g' -e 's/\.\([0-9]\)/0\1/g' -e 's/^[0-9]\{3,4\}$$$$/&00/')
+
+  ifeq ($$(shell expr $${versn} \>= $${min}), 0)
+    $$(error '$${path}' version '$${vers}' too old; at least version $3 is required)
+  endif
+endef
+
+$(eval $(call TEST_VERSION, git,     3, 2.12))
+$(eval $(call TEST_VERSION, ${MAKE}, 3, 3.81))
+
+#
+#  Initialize submodules if they aren't here yet.
+#   - if the submodule directory exists and it is empty, then have
+#     git fetch the submodule (with some fancy logging).
+#
+
+define INIT_SUBMODULE
+  ifeq ($$(wildcard ${1}),${1})
+  ifeq ($$(wildcard ${1}/*),)
+    $$(info Fetching submodule '${1}')
+    $$(shell cd $$(dir ${1}) ; git submodule update --init ${2} $$(notdir ${1}) 2>&1 | awk '{ print " - "$$$$0 }' 1>&2)
+    $$(info )
+  endif
+  endif
+endef
+
+$(eval $(call INIT_SUBMODULE,utility,))
+#(eval $(call INIT_SUBMODULE,meryl,))
+#(eval $(call INIT_SUBMODULE,seqrequester,))
+
+#
+#  Set compiler and flags based on operating system and compiler toolchain.
+#  This must be called AFTER the compiler is chosen, and after the decision
+#  to include stack trace support is make.
+#
+#  User-supplied flags are handled:
+#    If a parameter to make ("make CXXFLAGS=whatever"):
+#      flags are used exclusively; no default flags are supplied
+#    If an environment variable ("CXXFLAGS=whatever make"):
+#      flags are appended to the end of the default flags.
+#
+#  Parameters to the function:
+#    $1 - extra flags for CFLAGS/CXXFLAGS (e.g., -I/path)
+#    $2 - extra flags for LDFLAGS (e.g., -L/path)
+#
+#  Options:
+#    BUILDOPTIMIZED  will disable debug symbols (leaving it just optimized)
+#    BUILDDEBUG      will disable optimization  (leaving it just with debug symbols)
+#    BUILDSTACKTRACE will enable stack trace on crashes, only works for Linux
+#                    set to 0 on command line to disable (it's enabled by default for Linux)
+#
+#  BUILDPROFILE used to add -pg to LDFLAGS, and remove -D_GLIBCXX_PARALLE from CXXFLAGS and LDFLAGS,
+#  and remove -fomit-frame-pointer from CXXFLAGS.  It added a bunch of complication and wasn't
+#  really used.
+#
+#  BUILDJEMALLOC will enable jemalloc library support.
+#
+define SET_DEFAULT_FLAGS
+  CFLAGSUSER   := $${CFLAGS}
+  CXXFLAGSUSER := $${CXXFLAGS}
+  LDFLAGSUSER  := $${LDFLAGS}
+
+  #  Figure out which tool chain we're using and set up initial flags.
+  #   - GCC seems to want '-dumpfullversion' instead of '-dumpversion'
+  #     to return the full X.Y.Z version number.
+  #   - GCC has deprecated c++2a but gcc-9 doesn't know the correct
+  #     option c++20.
+
+  ifeq ($$(shell echo `$$(CXX) --version 2>&1 | grep -c clang`), 0)
+    TOOLCHAIN  := GNU
+    TOOLCHAINV := $$(shell ${CXX} -dumpfullversion)
+    CFLAGS     := -pthread -fopenmp -fPIC -std=c17   ${1}
+    CXXFLAGS   := -pthread -fopenmp -fPIC -std=c++2a ${1}
+    LDFLAGS    := -pthread -fopenmp                  ${2} -lm
+  else
+    TOOLCHAIN  := LLVM
+    TOOLCHAINV := $$(shell ${CXX} -dumpversion)
+    CFLAGS     := -pthread -fopenmp -fPIC -std=c17   ${1}
+    CXXFLAGS   := -pthread -fopenmp -fPIC -std=c++20 ${1}
+    LDFLAGS    := -pthread -fopenmp                  ${2} -lm
+  endif
+
+  #  Build up our preferred set of flags.
+
+  ifeq ($$(BUILDOPTIMIZED), 1)   #  Enable debugging and add debug-aware
+  else                           #  optimization unless BUILDOPTIMIZED is set.
+    CXXFLAGS += -Og -g3
+    CFLAGS   += -Og -g3
+  endif
+
+  ifeq ($$(BUILDDEBUG), 1)       #  Add full optimization unless BUILDDEBUG is set.
+  else ifeq ($$(TOOLCHAIN), GNU)
+    CXXFLAGS += -O4 -funroll-loops -finline-functions -fomit-frame-pointer -fexpensive-optimizations
+    CFLAGS   += -O4 -funroll-loops -finline-functions -fomit-frame-pointer -fexpensive-optimizations
+  else ifeq ($$(TOOLCHAIN), LLVM)
+    CXXFLAGS += -O3 -funroll-loops -finline-functions -fomit-frame-pointer
+    CFLAGS   += -O3 -funroll-loops -finline-functions -fomit-frame-pointer
+  else
+    CXXFLAGS += -O3
+    CFLAGS   += -O3
+  endif
+
+  ifeq ($${BUILDSTACKTRACE}, 1)  #  Add (or disable) stacktrace support.
+    CXXFLAGS += -DLIBBACKTRACE
+    CFLAGS   += -DLIBBACKTRACE
+  else
+    CXXFLAGS += -DNOBACKTRACE
+    CFLAGS   += -DNOBACKTRACE
+  endif
+
+  ifeq ($$(BUILDJEMALLOC), 1)    #  Add jemalloc support.
+    CXXFLAGS += -DJEMALLOC -I`jemalloc-config --includedir`
+    LDFLAGS  += -L`jemalloc-config --libdir` -Wl,-rpath,`jemalloc-config --libdir` -ljemalloc `jemalloc-config --libs`
+  endif
+
+  ifeq ($$(MACHINETYPE), amd64)  #  Add SIMD support (htslib and meryl-utility need this)
+    CFLAGS   += -mxsave
+    CXXFLAGS += -mxsave
+  endif
+
+  #  Enable gobs of warnings, but then disable some of the annoying ones, a
+  #  few of which are compiler dependent.
+
+  DEFAULTWARNINGS  =
+  #EFAULTWARNINGS += -DMACHINETYPE_${MACHINETYPE}
+  #EFAULTWARNINGS += -pedantic
+  DEFAULTWARNINGS += -Wall -Wextra -Wformat
+  DEFAULTWARNINGS += -Wno-char-subscripts
+  DEFAULTWARNINGS += -Wno-sign-compare
+  DEFAULTWARNINGS += -Wno-unused-function
+  DEFAULTWARNINGS += -Wno-unused-parameter
+  DEFAULTWARNINGS += -Wno-unused-variable
+  DEFAULTWARNINGS += -Wno-deprecated-declarations
+  #EFAULTWARNINGS += -Wno-format -Wno-format-truncation  #  Disable 'sprintf() into possibly smaller buffer'
+
+  ifeq ($$(TOOLCHAIN), LLVM)
+    CFLAGS   += $${DEFAULTWARNINGS} -Wno-format
+    CXXFLAGS += $${DEFAULTWARNINGS} -Wno-format
+  endif
+
+  ifeq ($$(TOOLCHAIN), GNU)
+    CFLAGS   += $${DEFAULTWARNINGS} -Wno-format-truncation
+    CXXFLAGS += $${DEFAULTWARNINGS} -Wno-format-truncation
+  endif
+
+  DEFAULTWARNINGS =
+
+  #  Append user-supplied flags, if any exist.
+
+  ifneq ($${CFLAGSUSER}, )
+    CFLAGS   += $${CFLAGSUSER}
+  endif
+  ifneq ($${CXXFLAGSUSER}, )
+    CXXFLAGS += $${CXXFLAGSUSER}
+  endif
+  ifneq ($${LDFLAGSUSER}, )
+    LDFLAGS += $${LDFLAGSUSER}
+  endif
+endef
+
+
+#
+#  Linux config.
+#
+ifeq (${OSTYPE}, Linux)
+  CC        ?= gcc
+  CXX       ?= g++
+
+  BUILDSTACKTRACE ?= 1
+
+  $(eval $(call SET_DEFAULT_FLAGS,,))
+endif
+
+
+#
+#  FreeBSD config.
+#
+#  If building in the FreeBSD ports system, use the architecture as defined
+#  there (technically, -p, not -m) and assume compiler and most options are
+#  already defined correctly.
+#
+#  We used to (for non-ports builds) default to gcc, mostly because the rpath
+#  was necessary.  But clang is working well, and rpath doesn't seem to be
+#  necessary on FreeBSD13.
+#    ifeq ($(origin CXX), default)
+#      CC    = gcc9
+#      CXX   = g++9
+#      CCLIB = -rpath /usr/local/lib/gcc9
+#    endif
+#
+ifeq (${OSTYPE}, FreeBSD)
+ifeq (${CANU_BUILD_ENV}, ports)
+  MACHINETYPE=${ARCH}
+
+  CXXFLAGS  += -pthread -fopenmp -fPIC
+  CFLAGS    += -pthread -fopenmp -fPIC
+  LDFLAGS   += -pthread -fopenmp -lm
+else
+  CC        ?= cc
+  CXX       ?= c++
+
+  BUILDSTACKTRACE ?= 1
+
+  $(eval $(call SET_DEFAULT_FLAGS,,))
+endif
+endif
+
+
+#
+#  MacOS config.
+#
+#  The default compiler in MacOS _still_ doesn't support OpenMP, so
+#  we try a bunch of common alternate compiler names and use the first
+#  one that exists.
+#
+#  If from MacPorts:             If from homebrew:
+#    port install gcc9             brew install gcc
+#    port select gcc mp-gcc9       brew install llvm
+#
+#  Homebrew calls its binaries clang and clang++ and uses directories to
+#  differentiate.  (While there is clang-16, there is no clang++-16, and we
+#  use clang/clang++ for consistency.)
+#    /opt/homebrew/opt/gcc@11/bin/gcc-12   /opt/homebrew/opt/llvm@16/bin/clang
+#    /opt/homebrew/opt/gcc@11/bin/g++-12   /opt/homebrew/opt/llvm@16/bin/clang++
+#
+#  MacPorts puts its binaries in the global bin directory with a suffix to
+#  differentiate.
+#    /opt/local/bin/gcc-mp-16           /opt/local/bin/clang-mp-16
+#    /opt/local/bin/g++-mp-16           /opt/local/bin/clang++-mp-16
+#
+define FIND_MACOS_COMPILER
+  ifeq ($$(CC), cc)
+  ifneq ($$(wildcard $${BREW}/opt/gcc@${1}/bin/gcc-${1}), )
+  ifneq ($$(wildcard $${BREW}/opt/gcc@${1}/bin/g++-${1}), )
+    #$$(info Detected gcc-${1} installed via Homebrew.)
+    CC=$$(abspath $${BREW}/opt/gcc@${1}/bin/gcc-${1})
+    CXX=$$(abspath $${BREW}/opt/gcc@${1}/bin/g++-${1})
+  endif
+  endif
+  endif
+
+  ifeq ($$(CC), cc)
+  ifneq ($$(wildcard $${BREW}/opt/llvm@${1}/bin/clang), )
+  ifneq ($$(wildcard $${BREW}/opt/llvm@${1}/bin/clang++), )
+    #$$(info Detected llvm-${1} installed via Homebrew.)
+    CC=$$(abspath $${BREW}/opt/llvm@${1}/bin/clang)
+    CXX=$$(abspath $${BREW}/opt/llvm@${1}/bin/clang++)
+  endif
+  endif
+  endif
+
+  ifeq ($$(CC), cc)
+  ifneq ($$(wildcard $${PORT}/bin/gcc-mp-${1}), )
+  ifneq ($$(wildcard $${PORT}/bin/g++-mp-${1}), )
+    #$$(info Detected gcc-${1} installed via MacPorts.)
+    CC=$$(abspath $${PORT}/bin/gcc-mp-${1})
+    CXX=$$(abspath $${PORT}/bin/g++-mp-${1})
+  endif
+  endif
+  endif
+
+  ifeq ($$(CC), cc)
+  ifneq ($$(wildcard $${PORT}/bin/clang-mp-${1}), )
+  ifneq ($$(wildcard $${PORT}/bin/clang++-mp-${1}), )
+    #$$(info Detected llvm-${1} installed via MacPorts.)
+    CC=$$(abspath $${PORT}/bin/clang-mp-${1})
+    CXX=$$(abspath $${PORT}/bin/clang++-mp-${1})
+  endif
+  endif
+  endif
+endef
+
+ifeq (${OSTYPE}, Darwin)
+  BREW := $(abspath $(lastword $(shell brew 2>/dev/null config | grep HOMEBREW_PREFIX)))
+  PORT := $(abspath $(dir $(abspath $(dir $(shell which port)))))
+
+  #$(info Detected Homebrew in '${BREW}')
+  #$(info Detected MacPorts in '${PORT}')
+
+  $(eval $(call FIND_MACOS_COMPILER,20))
+  $(eval $(call FIND_MACOS_COMPILER,19))
+  $(eval $(call FIND_MACOS_COMPILER,18))
+  $(eval $(call FIND_MACOS_COMPILER,17))
+  $(eval $(call FIND_MACOS_COMPILER,16))
+  $(eval $(call FIND_MACOS_COMPILER,15))
+  $(eval $(call FIND_MACOS_COMPILER,14))
+  $(eval $(call FIND_MACOS_COMPILER,13))
+  $(eval $(call FIND_MACOS_COMPILER,12))
+  $(eval $(call FIND_MACOS_COMPILER,11))
+  $(eval $(call FIND_MACOS_COMPILER,10))
+  $(eval $(call FIND_MACOS_COMPILER,9))
+  $(eval $(call FIND_MACOS_COMPILER,8))
+
+  $(eval $(call SET_DEFAULT_FLAGS,,))
+endif
+
+
+#
+#  Cygwin config.
+#
+ifneq (,$(findstring CYGWIN, ${OSTYPE}))
+  CC        ?= gcc
+  CXX       ?= g++
+
+  $(eval $(call SET_DEFAULT_FLAGS,,))
+endif
+
+
+#
+#  Test a small compile.
+#
+#  This has only failed on MacOS with default compilers that do not support
+#  -fopenmp.
+#
+#  Note that .SHELLSTATUS was introduced in Make 4.2 but stupid MacOS ships
+#  with make 3.81, so we need to do the success/fail test the hard way.  On
+#  the otherhand, this does mean we can clean up temporary files right after.
+#
+
+COMPILETEST := $(shell echo "int main(void) { return 0; }" | ${CXX} ${CXXFLAGS} ${LDFLAGS} -x c++ -o /tmp/test-fopenmp - && echo pass ; rm -f /tmp/test-fopenmp /tmp/test-fopenmp.C)
+
+ifneq ($(COMPILETEST), pass)
+  $(warning )
+  $(warning Unable to compile OpenMP programs with with:)
+  $(warning $_    ${TOOLCHAIN} ${CXX} ${TOOLCHAINV}.)
+  $(warning $_  CXXFLAGS flags:)
+  $(foreach FLAG,${CXXFLAGS},$(warning $_    ${FLAG}))
+  $(warning $_  LDFLAGS flags:)
+  $(foreach FLAG,${LDFLAGS},$(warning $_    ${FLAG}))
+  $(warning Please install GCC or LLVM with OpenMP support and)
+  $(warning specify this compiler on the command line, e.g.,)
+  $(warning $_    make CC=/path/to/gcc CXX=/path/to/g++)
+  $(warning )
+  $(error Unsupported compiler)
+endif
+
+#
+# Define the two exported targets, 'all' and 'clean' as phony rules that
+# point to the real rules.  This is done before including main.mk so that it
+# can define any weird one-off special-case targets without them becoming the
+# first (and thus default) rule.
+#
+# Then recursively include user-supplied submakefiles.
+#
+# Then define the real 'all' and 'clean' targets.
+#
+# Targets 'doall' and 'doclean' are used internally to add more targets to
+# the global build.  'doclean-final' is a trouble maker because it needs to
+# run after all the other 'doclean' steps, and the only way to ensure that is
+# to give it a new target.
+#
+
+.PHONY: all
+all: doall
+
+.PHONY: clean
+clean: doclean-final
+
+$(eval $(call INCLUDE_SUBMAKEFILE,main.mk))
+
+.PHONY: doall
+doall: $(addprefix ${TARGET_DIR}/,${ALL_TGTS})
+	@echo ""
+	@echo "Success!"
+	@echo "${MODULE} installed in ${TARGET_DIR}/bin/${MODULE}"
+	@echo ""
+
+.PHONY: doclean-final
+doclean-final: doclean
+	if [ -d ${TARGET_DIR} ] ; then find ${TARGET_DIR} -type d -print | sort -r | xargs -n 100 rmdir ; fi
+	@echo ""
+	@echo "Cleaned."
+	@echo ""
+
+.PHONY: doclean
+doclean:
+
+#
+#  Let boilermake do its thing.
+#
+
+$(eval $(call BOILERMAKE))
+
+#
+#  Generate a version number.  This needs to come AFTER submakefiles are
+#  included (so we know what ${MODULE} is) but before we build anything
+#  (because this generates 'version.H' and also prints information about
+#  submodule versions).
+#
+#  But, because make helpfully squashes all the lines to a single line we
+#  need to do something funky and write the version information for C++ and
+#  for make to one file - which then is included here and in source files.
+#  Makefile.boilermake adds this file as a dependency to ALL source files.
+#
+#  For projects that include meryl-utility as a submodule (the usual case)
+#  write version.H in the submodule src/ directory; for meryl-utility itself,
+#  write in the current directory.
+#   - This _should_ be indentifying if the submodule exists in
+#     utility/src, but on the very first build (when the submodules
+#     are initialized above) a file-based detection was reliably failing,
+#     as if `ifeq ($(wildcard utility/src), utility/src)` was tested
+#     before the submodule was init'd.  Rather than deal with all
+#     that baloney, we just assume that any build using this build
+#     system is either meryl-utility itself or something that uses it.
+#
+
+VERSION_H := $(shell ./${VERSION_H:.H=.pl} ${MODULE} ${VERSION} ${VERSION_H})
+
+ifeq (${VERSION_H}, )
+$(error Failed to create version.H, possibly missing the 'meryl-utility' submodule)
+endif
+
+include ${VERSION_H}
+
+#
+#  Log what compiler we're using and start the build.
+#
+
+$(info ${BUILDING})
+$(info For '${OSTYPE}' '${OSVERSION}' as '${MACHINETYPE}' into '${TARGET_DIR}/{bin,obj}'.)
+$(info Using ${TOOLCHAIN} '$(shell which ${CXX})' version '${TOOLCHAINV}'.)
+ifneq (${CFLAGSUSER},)
+$(info Using user-supplied CFLAGS   '${CFLAGSUSER}'.)
+endif
+ifneq (${CXXFLAGSUSER},)
+$(info Using user-supplied CXXFLAGS '${CXXFLAGSUSER}'.)
+endif
+ifneq (${LDFLAGSUSER},)
+$(info Using user-supplied LDFLAGS  '${LDFLAGSUSER}'.)
+endif
+$(info )