--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/seqrequester/src/Makefile.boilermake	Sat Jul 13 12:39:06 2024 +0000
@@ -0,0 +1,414 @@
+# -*- 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
+#
+
+
+#
+#  Set paths for building and installing.  If DESTDIR is defined,
+#  use that, otherwise, use the directory just above us.
+#
+#  We used to use "OSTYPE-MACHINETYPE" instead of "build" to allow
+#  multi-platform builds.  We now make the user set DESTDIR for that
+#  functionality.  The three variables are now just diagnostic info with some
+#  historical baggage (but even more was removed, like "Power Macintosh"
+#  detection).
+#
+ifeq "$(strip ${DESTDIR})" ""
+  BUILD_DIR    := $(realpath ..)/build/obj
+  TARGET_DIR   := $(realpath ..)/build
+else
+  BUILD_DIR    := $(DESTDIR)/build/obj
+  TARGET_DIR   := $(DESTDIR)/build
+endif
+
+OSTYPE      :=                      $(shell echo `uname`)
+OSVERSION   :=                      $(shell echo `uname -r`))
+MACHINETYPE := $(subst x86_64,amd64,$(shell echo `uname -m`))
+
+#
+# Define the source file extensions that we know how to handle.
+#
+C_SRC_EXTS   := %.c
+CXX_SRC_EXTS := %.C %.cc %.cp %.cpp %.CPP %.cxx %.c++
+JAVA_EXTS    := %.jar %.tar
+ALL_SRC_EXTS := ${C_SRC_EXTS} ${CXX_SRC_EXTS} ${JAVA_EXTS}
+
+#
+# Initialize internal variables.
+#
+ALL_TGTS  :=
+DIR_STACK :=
+TGT_STACK :=
+
+########################################
+#
+#  The single entry point to create all the targets and rules and everything.
+#
+#    $(eval $(call BOILERMAKE))
+#
+########################################
+
+define BOILERMAKE
+
+  # Add a new target rule for each user-defined target.
+  $(foreach TGT,${ALL_TGTS},\
+    $(eval $(call ADD_TARGET_RULE,${TGT})))
+
+  # Add pattern rule(s) for creating compiled object code from C source.
+  $(foreach TGT,${ALL_TGTS},\
+    $(foreach EXT,${C_SRC_EXTS},\
+      $(eval $(call ADD_OBJECT_RULE,${BUILD_DIR}/$(call CANONICAL_PATH,${TGT}),\
+               ${EXT},$${COMPILE_C_CMDS}))))
+
+  # Add pattern rule(s) for creating compiled object code from C++ source.
+  $(foreach TGT,${ALL_TGTS},\
+    $(foreach EXT,${CXX_SRC_EXTS},\
+      $(eval $(call ADD_OBJECT_RULE,${BUILD_DIR}/$(call CANONICAL_PATH,${TGT}),\
+               ${EXT},$${COMPILE_CXX_CMDS}))))
+
+  # Add "clean" rules to remove all build-generated files.
+  $(foreach TGT,${ALL_TGTS},\
+    $(eval $(call ADD_CLEAN_RULE,${TGT})))
+
+  # Include generated rules that define additional (header) dependencies
+  # (but don't complain if that file doesn't exist).
+  $(foreach TGT,${ALL_TGTS},\
+    $(eval -include ${${TGT}_DEPS}))
+
+  # Define more targets to copy files to the target directory.
+  $(call ADD_FILE_COPY_RULES,${EXECUTABLES},executable)
+  $(call ADD_FILE_COPY_RULES,${FILES},)
+endef
+
+
+############################################################
+#
+#  boilermake internal functions below.
+#
+############################################################
+
+#
+#  Adds a new rule and phony target for cleaning the specified target
+#  (removing its build-generated files).  Use with EVAL.
+#
+define ADD_CLEAN_RULE
+  doclean: doclean-${1}
+  .PHONY: doclean-${1}
+  doclean-${1}:
+		$$(strip rm -f ${TARGET_DIR}/${1} $${${1}_OBJS:%.o=%.[doP]})
+		$${${1}_POSTCLEAN}
+endef
+
+#  ADD_FILE_COPY_RULES adds rules to copy source files directly to the
+#  TARGET_DIR and optionally make them executable.  A rule to remove the
+#  copied file (on 'make clean') is also added.  It expects a list of files
+#  to copy and their destination:
+#
+#    EXECUTABLES += scripts/a         -> bin/b       #  These go in main.mk
+#
+#    FILES       += scripts/module/c  -> lib/site_perl/module/d \
+#                   data/e            -> share/data/f
+#
+#    $(call ADD_FILE_COPY_RULES,${EXECS},)           #  These go in Makefile!
+#    $(call ADD_FILE_COPY_RULES,${FILES},)
+#
+#  Source locations are relative to the submakefile location, and destination
+#  locations are relative to TARGET_DIR (e.g., 'build/'.  Destination
+#  directories are created if needed.
+#
+#  If the second parameter is the "executable", then the copied file is made
+#  executable.
+#
+#  ADD_FILE_COPY_RULE does the work of adding the rules, copying the first
+#  parameter to the second parameter and setting +x if the third parameter is
+#  "executable".
+#
+#  MAKE_FILE_COPY_LIST strips whitespace from around the 'file copy' operator
+#  '->' in the user-supplied file-copy-list.  It works by first squashing
+#  adjacent white space to a single space, then replacing adjacent whitespace
+#  with nothing.
+#
+#  (The $\ at the end of some of these lines serve to eat up whitespace
+#   before the continued line.)
+#
+define MAKE_FILE_COPY_LIST
+  $(subst         $  ->$ ,->,$\
+          $(subst $ -> $ ,->,$\
+                  $(strip ${1})))
+endef
+
+define ADD_FILE_COPY_RULE
+  doall: $${TARGET_DIR}/$2
+  ifeq ($3,executable)
+  $${TARGET_DIR}/$2: $1
+		@mkdir -p $$(dir $${TARGET_DIR}/$2)
+		cp -pf $1 $${TARGET_DIR}/$2
+		chmod +x $${TARGET_DIR}/$2
+  else
+  $${TARGET_DIR}/$2: $1
+		@mkdir -p $$(dir $${TARGET_DIR}/$2)
+		cp -pf $1 $${TARGET_DIR}/$2
+  endif
+  doclean: doclean-$1
+  .PHONY: doclean-$1
+  doclean-$1:
+		rm -f $${TARGET_DIR}/$2
+endef
+
+define ADD_FILE_COPY_RULES
+  $(foreach R,$(call MAKE_FILE_COPY_LIST,$1),\
+            $(eval $(call ADD_FILE_COPY_RULE,$(firstword $(subst ->, ,${R})),$\
+                                             $(lastword  $(subst ->, ,${R})),$2)))
+endef
+
+#  Adds a pattern rule for building object files from source files with the
+#  filename extension specified in the second argument. The first argument
+#  must be the name of the base directory where the object files should
+#  reside (such that the portion of the path after the base directory will
+#  match the path to corresponding source files). The third argument must
+#  contain the rules used to compile the source files into object code form.
+#  Use with EVAL.
+#
+define ADD_OBJECT_RULE
+  ${1}/%.o: ${2} ${VERSION_H}
+		${3}
+endef
+
+#  Adds a new target to the Makefile.  Targets are executable files unless
+#  they end with '.a'.  Use with EVAL.
+#
+define ADD_TARGET_RULE
+  ifeq "$$(suffix ${1})" ".a"
+    # Add a target for creating a static library.
+    $${TARGET_DIR}/${1}: $${${1}_OBJS}
+			@mkdir -p $$(dir $$@)
+			$$(strip $${AR} $${ARFLAGS} $$@ $${${1}_OBJS})
+			$${${1}_POSTMAKE}
+  else
+    # Add a target for linking an executable. First, attempt to select the
+    # appropriate front-end to use for linking. This might not choose the
+    # right one (e.g. if linking with a C++ static library, but all other
+    # sources are C sources), so the user makefile is allowed to specify a
+    # linker to be used for each target.
+    ifeq "$$(strip $${${1}_LINKER})" ""
+      # No linker was explicitly specified to be used for this target. If
+      # there are any C++ sources for this target, use the C++ compiler.
+      # For all other targets, default to using the C compiler.
+      ifneq "$$(strip $$(filter $${CXX_SRC_EXTS},$${${1}_SOURCES}))" ""
+        ${1}_LINKER = $${CXX}
+      else
+        ${1}_LINKER = $${CC}
+      endif
+    endif
+
+    $${TARGET_DIR}/${1}: $${${1}_OBJS} $${${1}_PREREQS}
+			@mkdir -p $$(dir $$@)
+			$$(strip $${${1}_LINKER} -o $$@ $${LDFLAGS} $${${1}_LDFLAGS} $${${1}_OBJS} $${${1}_LDLIBS} $${LDLIBS})
+			$${${1}_POSTMAKE}
+  endif
+endef
+
+# COMPILE_C_CMDS - Commands for compiling C source code.
+define COMPILE_C_CMDS
+	@mkdir -p $(dir $@)
+	$(strip ${CC} -o $@ -c -MD ${CFLAGS} ${SRC_CFLAGS} ${SRC_INCDIRS} ${SYS_INCDIRS} ${SRC_DEFS} $<)
+	@cp ${@:%$(suffix $@)=%.d} ${@:%$(suffix $@)=%.P}; \
+	 sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+	     -e '/^$$/ d' -e 's/$$/ :/' < ${@:%$(suffix $@)=%.d} \
+	     >> ${@:%$(suffix $@)=%.P}; \
+	 rm -f ${@:%$(suffix $@)=%.d}
+endef
+
+# COMPILE_CXX_CMDS - Commands for compiling C++ source code.
+define COMPILE_CXX_CMDS
+	@mkdir -p $(dir $@)
+	$(strip ${CXX} -o $@ -c -MD ${CXXFLAGS} ${SRC_CXXFLAGS} ${SRC_INCDIRS} ${SYS_INCDIRS} ${SRC_DEFS} $<)
+	@cp ${@:%$(suffix $@)=%.d} ${@:%$(suffix $@)=%.P}; \
+	 sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+	     -e '/^$$/ d' -e 's/$$/ :/' < ${@:%$(suffix $@)=%.d} \
+	     >> ${@:%$(suffix $@)=%.P}; \
+	 rm -f ${@:%$(suffix $@)=%.d}
+endef
+
+# INCLUDE_SUBMAKEFILE - Parameterized "function" that includes a new
+#   "submakefile" fragment into the overall Makefile. It also recursively
+#   includes all submakefiles of the specified submakefile fragment.
+#
+#   USE WITH EVAL
+#
+define INCLUDE_SUBMAKEFILE
+  # Initialize all variables that can be defined by a makefile fragment, then
+  # include the specified makefile fragment.
+  TARGET        :=
+  TGT_LDFLAGS   :=
+  TGT_LDLIBS    :=
+  TGT_LINKER    :=
+  TGT_PREREQS   :=
+
+  SOURCES       :=
+  SRC_CFLAGS    :=
+  SRC_CXXFLAGS  :=
+  SRC_DEFS      :=
+  SRC_INCDIRS   :=
+
+  SYS_INCDIRS   :=
+
+  SUBMAKEFILES  :=
+
+  # A directory stack is maintained so that the correct paths are used as we
+  # recursively include all submakefiles. Get the makefile's directory and
+  # push it onto the stack.
+  DIR := $(call CANONICAL_PATH,$(dir ${1}))
+  DIR_STACK := $$(call PUSH,$${DIR_STACK},$${DIR})
+
+  include ${1}
+
+  # Initialize internal local variables.
+  OBJS :=
+
+  # Determine which target this makefile's variables apply to. A stack is
+  # used to keep track of which target is the "current" target as we
+  # recursively include other submakefiles.
+  ifneq "$$(strip $${TARGET})" ""
+    # This makefile defined a new target. Target variables defined by this
+    # makefile apply to this new target. Initialize the target's variables.
+
+    ifeq "$$(suffix $${TARGET})" ".a"
+      TGT := $$(addprefix lib/, $$(strip $${TARGET}))
+    else
+      TGT := $$(addprefix bin/, $$(strip $${TARGET}))
+    endif
+    ALL_TGTS += $${TGT}
+    $${TGT}_DEPS      :=
+    $${TGT}_LDFLAGS   := $${TGT_LDFLAGS}
+    $${TGT}_LDLIBS    := $${TGT_LDLIBS}
+    $${TGT}_LINKER    := $${TGT_LINKER}
+    $${TGT}_OBJS      :=
+    $${TGT}_PREREQS   := $$(addprefix $${TARGET_DIR}/lib/,$${TGT_PREREQS})
+  else
+    # The values defined by this makefile apply to the the "current" target
+    # as determined by which target is at the top of the stack.
+    TGT := $$(strip $$(call PEEK,$${TGT_STACK}))
+    $${TGT}_LDFLAGS   += $${TGT_LDFLAGS}
+    $${TGT}_LDLIBS    += $${TGT_LDLIBS}
+    $${TGT}_PREREQS   += $${TGT_PREREQS}
+  endif
+
+  # Push the current target onto the target stack.
+  TGT_STACK := $$(call PUSH,$${TGT_STACK},$${TGT})
+
+  ifneq "$$(strip $${SOURCES})" ""
+    # This makefile builds one or more objects from source. Validate the
+    # specified sources against the supported source file types.
+    BAD_SRCS := $$(strip $$(filter-out $${ALL_SRC_EXTS},$${SOURCES}))
+    ifneq "$${BAD_SRCS}" ""
+      $$(error Unsupported source file(s) found in ${1} [$${BAD_SRCS}])
+    endif
+
+    # Qualify and canonicalize paths.
+    SOURCES     := $$(call QUALIFY_PATH,$${DIR},$${SOURCES})
+    SOURCES     := $$(call CANONICAL_PATH,$${SOURCES})
+    SRC_INCDIRS := $$(call QUALIFY_PATH,$${DIR},$${SRC_INCDIRS})
+    SRC_INCDIRS := $$(call CANONICAL_PATH,$${SRC_INCDIRS})
+    SYS_INCDIRS := $$(call QUALIFY_PATH,$${DIR},$${SYS_INCDIRS})
+    SYS_INCDIRS := $$(call CANONICAL_PATH,$${SYS_INCDIRS})
+
+    # Save the list of source files for this target.
+    $${TGT}_SOURCES += $${SOURCES}
+
+    # Convert the source file names to their corresponding object file
+    # names.
+    OBJS := $$(addprefix $${BUILD_DIR}/$$(call CANONICAL_PATH,$${TGT})/,\
+              $$(addsuffix .o,$$(basename $${SOURCES})))
+
+    # Add the objects to the current target's list of objects, and create
+    # target-specific variables for the objects based on any source
+    # variables that were defined.
+    $${TGT}_OBJS += $${OBJS}
+    $${TGT}_DEPS += $${OBJS:%.o=%.P}
+    $${OBJS}: SRC_CFLAGS   := $${SRC_CFLAGS}
+    $${OBJS}: SRC_CXXFLAGS := $${SRC_CXXFLAGS}
+    $${OBJS}: SRC_DEFS     := $$(addprefix -D,$${SRC_DEFS})
+    $${OBJS}: SRC_INCDIRS  := $$(addprefix -iquote,$${SRC_INCDIRS})
+    $${OBJS}: SYS_INCDIRS  := $$(addprefix -isystem,$${SYS_INCDIRS})
+  endif
+
+  ifneq "$$(strip $${SUBMAKEFILES})" ""
+    # This makefile has submakefiles. Recursively include them.
+    $$(foreach MK,$${SUBMAKEFILES},\
+      $$(eval $$(call INCLUDE_SUBMAKEFILE,\
+                $$(call CANONICAL_PATH,\
+                  $$(call QUALIFY_PATH,$${DIR},$${MK})))))
+  endif
+
+  # Reset the "current" target to it's previous value.
+  TGT_STACK := $$(call POP,$${TGT_STACK})
+  TGT := $$(call PEEK,$${TGT_STACK})
+
+  # Reset the "current" directory to it's previous value.
+  DIR_STACK := $$(call POP,$${DIR_STACK})
+  DIR := $$(call PEEK,$${DIR_STACK})
+endef
+
+
+# MIN - Parameterized "function" that results in the minimum lexical value of
+#   the two values given.
+#define MIN
+#$(firstword $(sort ${1} ${2}))
+#endef
+
+# PEEK - Parameterized "function" that results in the value at the top of the
+#   specified colon-delimited stack.
+define PEEK
+$(lastword $(subst :, ,${1}))
+endef
+
+# POP - Parameterized "function" that pops the top value off of the specified
+#   colon-delimited stack, and results in the new value of the stack. Note that
+#   the popped value cannot be obtained using this function; use peek for that.
+define POP
+${1:%:$(lastword $(subst :, ,${1}))=%}
+endef
+
+# PUSH - Parameterized "function" that pushes a value onto the specified colon-
+#   delimited stack, and results in the new value of the stack.
+define PUSH
+${2:%=${1}:%}
+endef
+
+# CANONICAL_PATH - Given one or more paths, converts the paths to the canonical
+#   form. The canonical form is the path, relative to the project's top-level
+#   directory (the directory from which "make" is run), and without
+#   any "./" or "../" sequences. For paths that are not  located below the
+#   top-level directory, the canonical form is the absolute path (i.e. from
+#   the root of the filesystem) also without "./" or "../" sequences.
+define CANONICAL_PATH
+$(patsubst ${CURDIR}/%,%,$(abspath ${1}))
+endef
+
+# QUALIFY_PATH - Given a "root" directory and one or more paths, qualifies the
+#   paths using the "root" directory (i.e. appends the root directory name to
+#   the paths) except for paths that are absolute.
+define QUALIFY_PATH
+$(addprefix ${1}/,$(filter-out /%,${2})) $(filter /%,${2})
+endef