http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/Makefile.base ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/Makefile.base b/thirdparty/librdkafka-0.11.4/mklove/Makefile.base new file mode 100755 index 0000000..d8af4ec --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/Makefile.base @@ -0,0 +1,215 @@ +# Base Makefile providing various standard targets +# Part of mklove suite but may be used independently. + +MKL_RED?= \033[031m +MKL_GREEN?= \033[032m +MKL_YELLOW?= \033[033m +MKL_BLUE?= \033[034m +MKL_CLR_RESET?= \033[0m + +DEPS= $(OBJS:%.o=%.d) + +# TOPDIR is "TOPDIR/mklove/../" i.e., TOPDIR. +# We do it with two dir calls instead of /.. to support mklove being symlinked. +MKLOVE_DIR := $(dir $(lastword $(MAKEFILE_LIST))) +TOPDIR = $(MKLOVE_DIR:mklove/=.) + + +# Convert LIBNAME ("libxyz") to "xyz" +LIBNAME0=$(LIBNAME:lib%=%) + +# Silence lousy default ARFLAGS (rv) +ARFLAGS= + +ifndef MKL_MAKEFILE_CONFIG +-include $(TOPDIR)/Makefile.config +endif + +_UNAME_S := $(shell uname -s) +ifeq ($(_UNAME_S),Darwin) + LIBFILENAME=$(LIBNAME).$(LIBVER)$(SOLIB_EXT) + LIBFILENAMELINK=$(LIBNAME)$(SOLIB_EXT) +else + LIBFILENAME=$(LIBNAME)$(SOLIB_EXT).$(LIBVER) + LIBFILENAMELINK=$(LIBNAME)$(SOLIB_EXT) +endif + +INSTALL?= install +INSTALL_PROGRAM?= $(INSTALL) +INSTALL_DATA?= $(INSTALL) -m 644 + +prefix?= /usr/local +exec_prefix?= $(prefix) +bindir?= $(exec_prefix)/bin +sbindir?= $(exec_prefix)/sbin +libexecdir?= $(exec_prefix)/libexec/ # append PKGNAME on install +datarootdir?= $(prefix)/share +datadir?= $(datarootdir) # append PKGNAME on install +sysconfdir?= $(prefix)/etc +sharedstatedir?=$(prefix)/com +localestatedir?=$(prefix)/var +runstatedir?= $(localestatedir)/run +includedir?= $(prefix)/include +docdir?= $(datarootdir)/doc/$(PKGNAME) +infodir?= $(datarootdir)/info +libdir?= $(prefix)/lib +localedir?= $(datarootdir)/locale +pkgconfigdir?= $(libdir)/pkgconfig +mandir?= $(datarootdir)/man +man1dir?= $(mandir)/man1 +man2dir?= $(mandir)/man2 +man3dir?= $(mandir)/man3 +man4dir?= $(mandir)/man4 +man5dir?= $(mandir)/man5 +man6dir?= $(mandir)/man6 +man7dir?= $(mandir)/man7 +man8dir?= $(mandir)/man8 + + +# Checks that mklove is set up and ready for building +mklove-check: + @if [ ! -f "$(TOPDIR)/Makefile.config" ]; then \ + printf "$(MKL_RED)$(TOPDIR)/Makefile.config missing: please run ./configure$(MKL_CLR_RESET)\n" ; \ + exit 1 ; \ + fi + +%.o: %.c + $(CC) -MD -MP $(CPPFLAGS) $(CFLAGS) -c $< -o $@ + +%.o: %.cpp + $(CXX) -MD -MP $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@ + + +lib: $(LIBFILENAME) $(LIBNAME).a $(LIBFILENAMELINK) lib-gen-pkg-config + +$(LIBNAME).lds: #overridable + +$(LIBFILENAME): $(OBJS) $(LIBNAME).lds + @printf "$(MKL_YELLOW)Creating shared library $@$(MKL_CLR_RESET)\n" + $(CC) $(LDFLAGS) $(LIB_LDFLAGS) $(OBJS) -o $@ $(LIBS) + +$(LIBNAME).a: $(OBJS) + @printf "$(MKL_YELLOW)Creating static library $@$(MKL_CLR_RESET)\n" + $(AR) rcs$(ARFLAGS) $@ $(OBJS) + +$(LIBFILENAMELINK): $(LIBFILENAME) + @printf "$(MKL_YELLOW)Creating $@ symlink$(MKL_CLR_RESET)\n" + rm -f "$@" && ln -s "$^" "$@" + + +# pkg-config .pc file definition +ifeq ($(GEN_PKG_CONFIG),y) +define _PKG_CONFIG_DEF +prefix=$(prefix) +libdir=$(libdir) +includedir=$(includedir) + +Name: $(LIBNAME) +Description: $(MKL_APP_DESC_ONELINE) +Version: $(MKL_APP_VERSION) +Cflags: -I$${includedir} +Libs: -L$${libdir} -l$(LIBNAME0) +Libs.private: $(LIBS) +endef + +export _PKG_CONFIG_DEF + +define _PKG_CONFIG_STATIC_DEF +prefix=$(prefix) +libdir=$(libdir) +includedir=$(includedir) + +Name: $(LIBNAME)-static +Description: $(MKL_APP_DESC_ONELINE) (static) +Version: $(MKL_APP_VERSION) +Cflags: -I$${includedir} +Libs: -L$${libdir} $${libdir}/$(LIBNAME).a $(LIBS) +endef + +export _PKG_CONFIG_STATIC_DEF + +$(LIBNAME0).pc: $(TOPDIR)/Makefile.config + @printf "$(MKL_YELLOW)Generating pkg-config file $@$(MKL_CLR_RESET)\n" + @echo "$$_PKG_CONFIG_DEF" > $@ + +$(LIBNAME0)-static.pc: $(TOPDIR)/Makefile.config + @printf "$(MKL_YELLOW)Generating pkg-config file $@$(MKL_CLR_RESET)\n" + @echo "$$_PKG_CONFIG_STATIC_DEF" > $@ + +lib-gen-pkg-config: $(LIBNAME0).pc $(LIBNAME0)-static.pc + +lib-clean-pkg-config: + rm -f $(LIBNAME0).pc $(LIBNAME0)-static.pc +else +lib-gen-pkg-config: +lib-clean-pkg-config: +endif + + +$(BIN): $(OBJS) + @printf "$(MKL_YELLOW)Creating program $@$(MKL_CLR_RESET)\n" + $(CC) $(CPPFLAGS) $(LDFLAGS) $(OBJS) -o $@ $(LIBS) + + +file-check: + @printf "$(MKL_YELLOW)Checking $(LIBNAME) integrity$(MKL_CLR_RESET)\n" + @RET=true ; \ + for f in $(CHECK_FILES) ; do \ + printf "%-30s " $$f ; \ + if [ -f "$$f" ]; then \ + printf "$(MKL_GREEN)OK$(MKL_CLR_RESET)\n" ; \ + else \ + printf "$(MKL_RED)MISSING$(MKL_CLR_RESET)\n" ; \ + RET=false ; \ + fi ; \ + done ; \ + $$RET + + +lib-install: + @printf "$(MKL_YELLOW)Install $(LIBNAME) to $$DESTDIR$(prefix)$(MKL_CLR_RESET)\n" + $(INSTALL) -d $$DESTDIR$(includedir)/$(PKGNAME) ; \ + $(INSTALL) -d $$DESTDIR$(libdir) ; \ + $(INSTALL) $(HDRS) $$DESTDIR$(includedir)/$(PKGNAME) ; \ + $(INSTALL) $(LIBNAME).a $$DESTDIR$(libdir) ; \ + $(INSTALL) $(LIBFILENAME) $$DESTDIR$(libdir) ; \ + [ -f "$(LIBNAME0).pc" ] && ( \ + $(INSTALL) -d $$DESTDIR$(pkgconfigdir) ; \ + $(INSTALL) -m 0644 $(LIBNAME0).pc $$DESTDIR$(pkgconfigdir) \ + ) ; \ + [ -f "$(LIBNAME0)-static.pc" ] && ( \ + $(INSTALL) -d $$DESTDIR$(pkgconfigdir) ; \ + $(INSTALL) -m 0644 $(LIBNAME0)-static.pc $$DESTDIR$(pkgconfigdir) \ + ) ; \ + (cd $$DESTDIR$(libdir) && ln -sf $(LIBFILENAME) $(LIBFILENAMELINK)) + +lib-uninstall: + @printf "$(MKL_YELLOW)Uninstall $(LIBNAME) from $$DESTDIR$(prefix)$(MKL_CLR_RESET)\n" + for hdr in $(HDRS) ; do \ + rm -f $$DESTDIR$(includedir)/$(PKGNAME)/$$hdr ; done + rm -f $$DESTDIR$(libdir)/$(LIBNAME).a + rm -f $$DESTDIR$(libdir)/$(LIBFILENAME) + rm -f $$DESTDIR$(libdir)/$(LIBFILENAMELINK) + rmdir $$DESTDIR$(includedir)/$(PKGNAME) || true + + + +bin-install: + @printf "$(MKL_YELLOW)Install $(BIN) to $$DESTDIR$(prefix)$(MKL_CLR_RESET)\n" + $(INSTALL) -d $$DESTDIR$(bindir) && \ + $(INSTALL) $(BIN) $$DESTDIR$(bindir) + +bin-uninstall: + @printf "$(MKL_YELLOW)Uninstall $(BIN) from $$DESTDIR$(prefix)$(MKL_CLR_RESET)\n" + rm -f $$DESTDIR$(bindir)/$(BIN) + + +generic-clean: + rm -f $(OBJS) $(DEPS) + +lib-clean: generic-clean lib-clean-pkg-config + rm -f $(LIBNAME)*.a $(LIBFILENAME) $(LIBFILENAMELINK) \ + $(LIBNAME).lds + +bin-clean: generic-clean + rm -f $(BIN)
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.atomics ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.atomics b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.atomics new file mode 100644 index 0000000..31639a7 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.atomics @@ -0,0 +1,144 @@ +#!/bin/bash +# +# Checks for atomic ops: +# compiler builtin (__sync_..) and portable libatomic's (__atomic_..) +# Will also provide abstraction by defining the prefix to use. +# +# Sets: +# HAVE_ATOMICS +# HAVE_ATOMICS_32 +# HAVE_ATOMICS_64 +# HAVE_ATOMICS_32_ATOMIC __atomic interface +# HAVE_ATOMICS_32_SYNC __sync interface +# HAVE_ATOMICS_64_ATOMIC __atomic interface +# HAVE_ATOMICS_64_SYNC __sync interface +# WITH_LIBATOMIC +# LIBS +# +# ATOMIC_OP(OP1,OP2,PTR,VAL) +# ATOMIC_OP32(OP1,OP2,PTR,VAL) +# ATOMIC_OP64(OP1,OP2,PTR,VAL) +# where op* is 'add,sub,fetch' +# e.g: ATOMIC_OP32(add, fetch, &i, 10) +# becomes __atomic_add_fetch(&i, 10, ..) or +# __sync_add_and_fetch(&i, 10) +# + +function checks { + + + # We prefer the newer __atomic stuff, but 64-bit atomics might + # require linking with -latomic, so we need to perform these tests + # in the proper order: + # __atomic 32 + # __atomic 32 -latomic + # __sync 32 + # + # __atomic 64 + # __atomic 64 -latomic + # __sync 64 + + local _libs= + local _a32="__atomic_ ## OP1 ## _ ## OP2(PTR, VAL, __ATOMIC_SEQ_CST)" + local _a64="__atomic_ ## OP1 ## _ ## OP2(PTR, VAL, __ATOMIC_SEQ_CST)" + + # 32-bit: + # Try fully builtin __atomic + if ! mkl_compile_check __atomic_32 HAVE_ATOMICS_32 cont CC "" \ + " +#include <inttypes.h> +int32_t foo (int32_t i) { + return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST); +}" + then + # Try __atomic with -latomic + if mkl_compile_check --ldflags="-latomic" __atomic_32_lib HAVE_ATOMICS_32 \ + cont CC "" \ + " +#include <inttypes.h> +int32_t foo (int32_t i) { + return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST); +}" + then + _libs="-latomic" + mkl_allvar_set "__atomic_32_lib" "HAVE_ATOMICS_32_ATOMIC" "y" + else + # Try __sync interface + if mkl_compile_check __sync_32 HAVE_ATOMICS_32 disable CC "" \ + " +#include <inttypes.h> +int32_t foo (int32_t i) { + return __sync_add_and_fetch(&i, 1); +}" + then + _a32="__sync_ ## OP1 ## _and_ ## OP2(PTR, VAL)" + mkl_allvar_set "__sync_32" "HAVE_ATOMICS_32_SYNC" "y" + else + _a32="" + fi + fi + else + mkl_allvar_set "__atomic_32" "HAVE_ATOMICS_32_ATOMIC" "y" + fi + + + if [[ ! -z $_a32 ]]; then + mkl_define_set "atomic_32" "ATOMIC_OP32(OP1,OP2,PTR,VAL)" "code:$_a32" + fi + + + + # 64-bit: + # Try fully builtin __atomic + if ! mkl_compile_check __atomic_64 HAVE_ATOMICS_64 cont CC "" \ + " +#include <inttypes.h> +int64_t foo (int64_t i) { + return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST); +}" + then + # Try __atomic with -latomic + if mkl_compile_check --ldflags="-latomic" __atomic_64_lib HAVE_ATOMICS_64 \ + cont CC "" \ + " +#include <inttypes.h> +int64_t foo (int64_t i) { + return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST); +}" + then + _libs="-latomic" + mkl_allvar_set "__atomic_64_lib" "HAVE_ATOMICS_64_ATOMIC" "y" + else + # Try __sync interface + if mkl_compile_check __sync_64 HAVE_ATOMICS_64 disable CC "" \ + " +#include <inttypes.h> +int64_t foo (int64_t i) { + return __sync_add_and_fetch(&i, 1); +}" + then + _a64="__sync_ ## OP1 ## _and_ ## OP2 (PTR, VAL)" + mkl_allvar_set "__sync_64" "HAVE_ATOMICS_64_SYNC" "y" + else + _a64="" + fi + fi + else + mkl_allvar_set "__atomic_64" "HAVE_ATOMICS_64_ATOMIC" "y" + fi + + + if [[ ! -z $_a64 ]]; then + mkl_define_set "atomic_64" "ATOMIC_OP64(OP1,OP2,PTR,VAL)" "code:$_a64" + + # Define generic ATOMIC() macro identical to 64-bit atomics" + mkl_define_set "atomic_64" "ATOMIC_OP(OP1,OP2,PTR,VAL)" "code:$_a64" + fi + + + if [[ ! -z $_libs ]]; then + mkl_mkvar_append LDFLAGS LDFLAGS "-Wl,--as-needed" + mkl_mkvar_append LIBS LIBS "$_libs" + fi + +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.base ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.base b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.base new file mode 100644 index 0000000..a776e43 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.base @@ -0,0 +1,1771 @@ +#!/bin/bash +# +# +# mklove base configure module, implements the mklove configure framework +# + +MKL_MODULES="base" +MKL_CACHEVARS="" +MKL_MKVARS="" +MKL_DEFINES="" +MKL_CHECKS="" +MKL_LOAD_STACK="" + +MKL_IDNEXT=1 + +MKL_OUTMK=_mklout.mk +MKL_OUTH=_mklout.h +MKL_OUTDBG=config.log + +MKL_GENERATORS="base:mkl_generate_late_vars" +MKL_CLEANERS="" + +MKL_FAILS="" +MKL_LATE_VARS="" + +MKL_OPTS_SET="" + +MKL_RED="" +MKL_GREEN="" +MKL_YELLOW="" +MKL_BLUE="" +MKL_CLR_RESET="" + + +MKL_NO_DOWNLOAD=0 + +if [[ -z "$MKL_REPO_URL" ]]; then + MKL_REPO_URL="http://github.com/edenhill/mklove/raw/master"; +fi + + + +# Default mklove directory to PWD/mklove +[[ -z "$MKLOVE_DIR" ]] && MKLOVE_DIR=mklove + + +########################################################################### +# +# Variable types: +# env - Standard environment variables. +# var - mklove runtime variable, cached or not. +# mkvar - Makefile variables, also sets runvar +# define - config.h variables/defines +# +########################################################################### + +# Low level variable assignment +# Arguments: +# variable name +# variable value +function mkl_var0_set { + export "$1"="$2" +} + +# Sets a runtime variable (only used during configure) +# If cache=1 these variables are cached to config.cache. +# Arguments: +# variable name +# variable value +# [ "cache" ] +function mkl_var_set { + mkl_var0_set "$1" "$2" + if [[ $3 == "cache" ]]; then + if ! mkl_in_list "$MKL_CACHEVARS" "$1" ; then + MKL_CACHEVARS="$MKL_CACHEVARS $1" + fi + fi +} + +# Unsets a mkl variable +# Arguments: +# variable name +function mkl_var_unset { + unset $1 +} + +# Appends to a mkl variable (space delimited) +# Arguments: +# variable name +# variable value +function mkl_var_append { + if [[ -z ${!1} ]]; then + mkl_var_set "$1" "$2" + else + mkl_var0_set "$1" "${!1} $2" + fi +} + + +# Prepends to a mkl variable (space delimited) +# Arguments: +# variable name +# variable value +function mkl_var_prepend { + if [[ -z ${!1} ]]; then + mkl_var_set "$1" "$2" + else + mkl_var0_set "$1" "$2 ${!1}" + fi +} + +# Shift the first word off a variable. +# Arguments: +# variable name +function mkl_var_shift { + local n="${!1}" + mkl_var0_set "$1" "${n#* }" + return 0 +} + + +# Returns the contents of mkl variable +# Arguments: +# variable name +function mkl_var_get { + echo "${!1}" +} + + + + +# Set environment variable (runtime) +# These variables are not cached nor written to any of the output files, +# its just simply a helper wrapper for standard envs. +# Arguments: +# varname +# varvalue +function mkl_env_set { + mkl_var0_set "$1" "$2" +} + +# Append to environment variable +# Arguments: +# varname +# varvalue +# [ separator (" ") ] +function mkl_env_append { + local sep=" " + if [[ -z ${!1} ]]; then + mkl_env_set "$1" "$2" + else + [ ! -z ${3} ] && sep="$3" + mkl_var0_set "$1" "${!1}${sep}$2" + fi + +} + +# Prepend to environment variable +# Arguments: +# varname +# varvalue +# [ separator (" ") ] +function mkl_env_prepend { + local sep=" " + if [[ -z ${!1} ]]; then + mkl_env_set "$1" "$2" + else + [ ! -z ${3} ] && sep="$3" + mkl_var0_set "$1" "$2${sep}${!1}" + fi + +} + + + + +# Set a make variable (Makefile.config) +# Arguments: +# config name +# variable name +# value +function mkl_mkvar_set { + if [[ ! -z $2 ]]; then + mkl_env_set "$2" "$3" + mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2 + fi +} + + +# Prepends to a make variable (Makefile.config) +# Arguments: +# config name +# variable name +# value +function mkl_mkvar_prepend { + if [[ ! -z $2 ]]; then + mkl_env_prepend "$2" "$3" + mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2 + fi +} + + +# Appends to a make variable (Makefile.config) +# Arguments: +# config name +# variable name +# value +function mkl_mkvar_append { + if [[ ! -z $2 ]]; then + mkl_env_append "$2" "$3" + mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2 + fi +} + + +# Prepends to a make variable (Makefile.config) +# Arguments: +# config name +# variable name +# value +function mkl_mkvar_prepend { + if [[ ! -z $2 ]]; then + mkl_env_prepend "$2" "$3" + mkl_in_list "$MKL_MKVARS" "$2"|| mkl_env_append MKL_MKVARS $2 + fi +} + +# Return mkvar variable value +# Arguments: +# variable name +function mkl_mkvar_get { + [[ -z ${!1} ]] && return 1 + echo ${!1} + return 0 +} + + + +# Defines a config header define (config.h) +# Arguments: +# config name +# define name +# define value (optional, default: 1) +# if value starts with code: then no "" are added +function mkl_define_set { + + if [[ -z $2 ]]; then + return 0 + fi + + local stmt="" + local defid= + if [[ $2 = *\(* ]]; then + # macro + defid="def_${2%%(*}" + else + # define + defid="def_$2" + fi + + [[ -z $1 ]] || stmt="// $1\n" + + local val="$3" + if [[ -z "$val" ]]; then + val="$(mkl_def $2 1)" + fi + + # Define as code, string or integer? + if [[ $val == code:* ]]; then + # Code block, copy verbatim without quotes, strip code: prefix + val=${val#code:} + elif [[ ! ( "$val" =~ ^[0-9]+([lL]?[lL][dDuU]?)?$ || \ + "$val" =~ ^0x[0-9a-fA-F]+([lL]?[lL][dDuU]?)?$ ) ]]; then + # String: quote + val="\"$val\"" + fi + # else: unquoted integer/hex + + stmt="${stmt}#define $2 $val" + mkl_env_set "$defid" "$stmt" + mkl_env_append MKL_DEFINES "$defid" +} + + + + + +# Sets "all" configuration variables, that is: +# for name set: Makefile variable, config.h define +# Will convert value "y"|"n" to 1|0 for config.h +# Arguments: +# config name +# variable name +# value +function mkl_allvar_set { + mkl_mkvar_set "$1" "$2" "$3" + local val=$3 + if [[ $3 = "y" ]]; then + val=1 + elif [[ $3 = "n" ]]; then + val=0 + fi + mkl_define_set "$1" "$2" "$val" +} + + + + +########################################################################### +# +# +# Check failure functionality +# +# +########################################################################### + + +# Summarize all fatal failures and then exits. +function mkl_fail_summary { + echo " + +" + + local pkg_cmd="" + local install_pkgs="" + mkl_err "###########################################################" + mkl_err "### Configure failed ###" + mkl_err "###########################################################" + mkl_err "### Accumulated failures: ###" + mkl_err "###########################################################" + local n + for n in $MKL_FAILS ; do + local conf=$(mkl_var_get MKL_FAIL__${n}__conf) + mkl_err " $conf ($(mkl_var_get MKL_FAIL__${n}__define)) $(mkl_meta_get $conf name)" + if mkl_meta_exists $conf desc; then + mkl_err0 " desc: $MKL_YELLOW$(mkl_meta_get $conf desc)$MKL_CLR_RESET" + fi + mkl_err0 " module: $(mkl_var_get MKL_FAIL__${n}__module)" + mkl_err0 " action: $(mkl_var_get MKL_FAIL__${n}__action)" + mkl_err0 " reason: +$(mkl_var_get MKL_FAIL__${n}__reason) +" + # Dig up some metadata to assist the user + case $MKL_DISTRO in + Debian|Ubuntu|*) + local debs=$(mkl_meta_get $conf "deb") + pkg_cmd="sudo apt-get install" + if [[ ${#debs} > 0 ]]; then + install_pkgs="$install_pkgs $debs" + fi + ;; + esac + done + + if [[ ! -z $install_pkgs ]]; then + mkl_err "###########################################################" + mkl_err "### Installing the following packages might help: ###" + mkl_err "###########################################################" + mkl_err0 "$pkg_cmd $install_pkgs" + mkl_err0 "" + fi + exit 1 +} + + +# Checks if there were failures. +# Returns 0 if there were no failures, else calls failure summary and exits. +function mkl_check_fails { + if [[ ${#MKL_FAILS} = 0 ]]; then + return 0 + fi + mkl_fail_summary +} + +# A check has failed but we want to carry on (and we should!). +# We fail it all later. +# Arguments: +# config name +# define name +# action +# reason +function mkl_fail { + local n="$(mkl_env_esc "$1")" + mkl_var_set "MKL_FAIL__${n}__conf" "$1" + mkl_var_set "MKL_FAIL__${n}__module" $MKL_MODULE + mkl_var_set "MKL_FAIL__${n}__define" $2 + mkl_var_set "MKL_FAIL__${n}__action" "$3" + if [[ -z $(mkl_var_get "MKL_FAIL__${n}__reason") ]]; then + mkl_var_set "MKL_FAIL__${n}__reason" "$4" + else + mkl_var_append "MKL_FAIL__${n}__reason" " +And also: +$4" + fi + mkl_in_list "$MKL_FAILS" "$n" || mkl_var_append MKL_FAILS "$n" +} + + +# A check failed, handle it +# Arguments: +# config name +# define name +# action (fail|disable|ignore|cont) +# reason +function mkl_check_failed { + # Override action based on require directives, unless the action is + # set to cont (for fallthrough to sub-sequent tests). + local action="$3" + if [[ $3 != "cont" ]]; then + action=$(mkl_meta_get "MOD__$MKL_MODULE" "override_action" $3) + fi + + # --fail-fatal option + [[ $MKL_FAILFATAL ]] && action="fail" + + mkl_check_done "$1" "$2" "$action" "failed" + + mkl_dbg "Check $1 ($2, action $action (originally $3)) failed: $4" + + + case $action in + fail) + # Check failed fatally, fail everything eventually + mkl_fail "$1" "$2" "$3" "$4$extra" + return 1 + ;; + + disable) + # Check failed, disable + [[ ! -z $2 ]] && mkl_mkvar_set "$1" "$2" "n" + return 1 + ;; + ignore) + # Check failed but we ignore the results and set it anyway. + [[ ! -z $2 ]] && mkl_define_set "$1" "$2" "1" + [[ ! -z $2 ]] && mkl_mkvar_set "$1" "$2" "y" + return 1 + ;; + cont) + # Check failed but we ignore the results and do nothing. + return 0 + ;; + esac +} + + + + +########################################################################### +# +# +# Output generators +# +# +########################################################################### + +# Generate late variables. +# Late variables are those referenced in command line option defaults +# but then never set by --option. +function mkl_generate_late_vars { + local n + for n in $MKL_LATE_VARS ; do + local func=${n%:*} + local safeopt=${func#opt_} + local val=${n#*:} + if mkl_in_list "$MKL_OPTS_SET" "$safeopt" ; then + # Skip options set explicitly with --option + continue + fi + # Expand variable references "\$foo" by calling eval + # and pass it opt_... function. + $func "$(eval echo $val)" + done +} + +# Generate output files. +# Must be called following a succesful configure run. +function mkl_generate { + local mf= + for mf in $MKL_GENERATORS ; do + MKL_MODULE=${mf%:*} + local func=${mf#*:} + $func || exit 1 + done + + mkl_write_mk "# Automatically generated by $0 $*" + mkl_write_mk "# Config variables" + mkl_write_mk "#" + mkl_write_mk "# Generated by:" + mkl_write_mk "# $MKL_CONFIGURE_ARGS" + mkl_write_mk "" + + # This variable is used by Makefile.base to avoid multiple inclusions. + mkl_write_mk "MKL_MAKEFILE_CONFIG=y" + + # Export colors to Makefile.config + mkl_write_mk "MKL_RED=\t${MKL_RED}" + mkl_write_mk "MKL_GREEN=\t${MKL_GREEN}" + mkl_write_mk "MKL_YELLOW=\t${MKL_YELLOW}" + mkl_write_mk "MKL_BLUE=\t${MKL_BLUE}" + mkl_write_mk "MKL_CLR_RESET=\t${MKL_CLR_RESET}" + + local n= + for n in $MKL_MKVARS ; do + # Some special variables should be prefixable by the caller, so + # define them in the makefile as appends. + local op="=" + case $n in + CFLAGS|CPPFLAGS|CXXFLAGS|LDFLAGS|LIBS) + op="+=" + ;; + esac + mkl_write_mk "$n$op\t${!n}" + done + mkl_write_mk "# End of config variables" + + MKL_OUTMK_FINAL=Makefile.config + mv $MKL_OUTMK $MKL_OUTMK_FINAL + + echo "Generated $MKL_OUTMK_FINAL" + + # Generate config.h + mkl_write_h "// Automatically generated by $0 $*" + mkl_write_h "#ifndef _CONFIG_H_" + mkl_write_h "#define _CONFIG_H_" + for n in $MKL_DEFINES ; do + mkl_write_h "${!n}" + done + mkl_write_h "#endif /* _CONFIG_H_ */" + + MKL_OUTH_FINAL=config.h + mv $MKL_OUTH $MKL_OUTH_FINAL + + echo "Generated $MKL_OUTH_FINAL" +} + +# Remove file noisily, if it exists +function mkl_rm { + if [[ -f $fname ]]; then + echo "Removing $fname" + rm -f "$fname" + fi +} + +# Remove files generated by configure +function mkl_clean { + for fname in Makefile.config config.h config.cache config.log ; do + mkl_rm "$fname" + done + + local mf= + for mf in $MKL_CLEANERS ; do + MKL_MODULE=${mf%:*} + local func=${mf#*:} + $func || exit 1 + done + +} + + +# Print summary of succesful configure run +function mkl_summary { + + echo " +Configuration summary:" + local n= + for n in $MKL_MKVARS ; do + # Skip the boring booleans + if [[ $n == WITH_* || $n == WITHOUT_* || $n == HAVE_* || $n == def_* ]]; then + continue + fi + printf " %-24s %s\n" "$n" "${!n}" + done +} + + + +# Write to mk file +# Argument: +# string .. +function mkl_write_mk { + echo -e "$*" >> $MKL_OUTMK +} + +# Write to header file +# Argument: +# string .. +function mkl_write_h { + echo -e "$*" >> $MKL_OUTH +} + + + +########################################################################### +# +# +# Logging and debugging +# +# +########################################################################### + +# Debug print +# Only visible on terminal if MKL_DEBUG is set. +# Always written to config.log +# Argument: +# string .. +function mkl_dbg { + if [[ ! -z $MKL_DEBUG ]]; then + echo -e "${MKL_BLUE}DBG:$$: $*${MKL_CLR_RESET}" 1>&2 + fi + echo "DBG: $*" >> $MKL_OUTDBG +} + +# Error print (with color) +# Always printed to terminal and config.log +# Argument: +# string .. +function mkl_err { + echo -e "${MKL_RED}$*${MKL_CLR_RESET}" 1>&2 + echo "$*" >> $MKL_OUTDBG +} + +# Same as mkl_err but without coloring +# Argument: +# string .. +function mkl_err0 { + echo -e "$*" 1>&2 + echo "$*" >> $MKL_OUTDBG +} + +# Standard print +# Always printed to terminal and config.log +# Argument: +# string .. +function mkl_info { + echo -e "$*" 1>&2 + echo -e "$*" >> $MKL_OUTDBG +} + + + + + + + +########################################################################### +# +# +# Misc helpers +# +# +########################################################################### + +# Returns the absolute path (but not necesarily canonical) of the first argument +function mkl_abspath { + echo $1 | sed -e "s|^\([^/]\)|$PWD/\1|" +} + +# Returns true (0) if function $1 exists, else false (1) +function mkl_func_exists { + declare -f "$1" > /dev/null + return $? +} + +# Rename function. +# Returns 0 on success or 1 if old function (origname) was not defined. +# Arguments: +# origname +# newname +function mkl_func_rename { + if ! mkl_func_exists $1 ; then + return 1 + fi + local orig=$(declare -f $1) + local new="$2${orig#$1}" + eval "$new" + unset -f "$1" + return 0 +} + + +# Push module function for later call by mklove. +# The function is renamed to an internal name. +# Arguments: +# list variable name +# module name +# function name +function mkl_func_push { + local newfunc="__mkl__f_${2}_$(( MKL_IDNEXT++ ))" + if mkl_func_rename "$3" "$newfunc" ; then + mkl_var_append "$1" "$2:$newfunc" + fi +} + + + +# Returns value, or the default string if value is empty. +# Arguments: +# value +# default +function mkl_def { + if [[ ! -z $1 ]]; then + echo $1 + else + echo $2 + fi +} + + +# Render a string (e.g., evaluate its $varrefs) +# Arguments: +# string +function mkl_render { + if [[ $* == *\$* ]]; then + eval "echo $*" + else + echo "$*" + fi +} + +# Escape a string so that it becomes suitable for being an env variable. +# This is a destructive operation and the original string cannot be restored. +function mkl_env_esc { + echo $* | LC_ALL=C sed -e 's/[^a-zA-Z0-9_]/_/g' +} + +# Convert arguments to upper case +function mkl_upper { + echo "$*" | tr '[:lower:]' '[:upper:]' +} + +# Convert arguments to lower case +function mkl_lower { + echo "$*" | tr '[:upper:]' '[:lower:]' +} + + +# Checks if element is in list +# Arguments: +# list +# element +function mkl_in_list { + local n + for n in $1 ; do + [[ $n == $2 ]] && return 0 + done + return 1 +} + + + + +########################################################################### +# +# +# Cache functionality +# +# +########################################################################### + + +# Write cache file +function mkl_cache_write { + [[ ! -z "$MKL_NOCACHE" ]] && return 0 + echo "# mklove configure cache file generated at $(date)" > config.cache + for n in $MKL_CACHEVARS ; do + echo "$n=${!n}" >> config.cache + done + echo "Generated config.cache" +} + + +# Read cache file +function mkl_cache_read { + [[ ! -z "$MKL_NOCACHE" ]] && return 0 + [ -f config.cache ] || return 1 + + echo "using cache file config.cache" + + local ORIG_IFS=$IFS + IFS="$IFS=" + while read -r n v ; do + [[ -z $n || $n = \#* || -z $v ]] && continue + mkl_var_set $n $v cache + done < config.cache + IFS=$ORIG_IFS +} + + +########################################################################### +# +# +# Config name meta data +# +# +########################################################################### + +# Set metadata for config name +# This metadata is used by mkl in various situations +# Arguments: +# config name +# metadata key +# metadata value (appended) +function mkl_meta_set { + local metaname="mkl__$1__$2" + eval "$metaname=\"\$$metaname $3\"" +} + +# Returns metadata for config name +# Arguments: +# config name +# metadata key +# default (optional) +function mkl_meta_get { + local metaname="mkl__$1__$2" + if [[ ! -z ${!metaname} ]]; then + echo ${!metaname} + else + echo "$3" + fi +} + +# Checks if metadata exists +# Arguments: +# config name +# metadata key +function mkl_meta_exists { + local metaname="mkl__$1__$2" + if [[ ! -z ${!metaname} ]]; then + return 0 + else + return 1 + fi +} + + + + + +########################################################################### +# +# +# Check framework +# +# +########################################################################### + + +# Print that a check is beginning to run +# Returns 0 if a cached result was used (do not continue with your tests), +# else 1. +# +# If the check should not be cachable then specify argument 3 as "no-cache", +# this is useful when a check not only checks but actually sets config +# variables itself (which is not recommended, but desired sometimes). +# +# Arguments: +# [ --verb "verb.." ] (replace "checking for") +# config name +# define name +# action (fail,cont,disable or no-cache) +# [ display name ] +function mkl_check_begin { + local verb="checking for" + if [[ $1 == "--verb" ]]; then + verb="$2" + shift + shift + fi + + local name=$(mkl_meta_get $1 name "$4") + [[ -z $name ]] && name="x:$1" + + echo -n "$verb $name..." + if [[ $3 != "no-cache" ]]; then + local status=$(mkl_var_get "MKL_STATUS_$1") + # Check cache (from previous run or this one). + # Only used cached value if the cached check succeeded: + # it is more likely that a failed check has been fixed than the other + # way around. + if [[ ! -z $status && ( $status = "ok" ) ]]; then + mkl_check_done "$1" "$2" "$3" $status "cached" + return 0 + fi + fi + return 1 +} + +# Print that a check is done +# Arguments: +# config name +# define name +# action +# status (ok|failed) +# extra-info (optional) +function mkl_check_done { + # Clean up configname to be a safe varname + local cname=${1//-/_} + mkl_var_set "MKL_STATUS_$cname" "$4" cache + + local extra="" + if [[ $4 = "failed" ]]; then + local clr=$MKL_YELLOW + extra=" ($3)" + case "$3" in + fail) + clr=$MKL_RED + ;; + cont) + extra="" + ;; + esac + echo -e " $clr$4$MKL_CLR_RESET${extra}" + else + [[ ! -z $2 ]] && mkl_define_set "$cname" "$2" "1" + [[ ! -z $2 ]] && mkl_mkvar_set "$cname" "$2" "y" + [ ! -z "$5" ] && extra=" ($5)" + echo -e " $MKL_GREEN$4${MKL_CLR_RESET}$extra" + fi +} + + +# Perform configure check by compiling source snippet +# Arguments: +# [--ldflags="..." ] (appended after "compiler arguments" below) +# config name +# define name +# action (fail|disable) +# compiler (CC|CXX) +# compiler arguments (optional "", example: "-lzookeeper") +# source snippet +function mkl_compile_check { + local ldf= + if [[ $1 == --ldflags=* ]]; then + ldf=${1#*=} + shift + fi + mkl_check_begin "$1" "$2" "$3" "$1 (by compile)" && return $? + + local cflags= + + if [[ $4 = "CXX" ]]; then + local ext=cpp + cflags="$(mkl_mkvar_get CXXFLAGS)" + else + local ext=c + cflags="$(mkl_mkvar_get CFLAGS)" + fi + + local srcfile=$(mktemp _mkltmpXXXXXX) + mv "$srcfile" "${srcfile}.$ext" + srcfile="$srcfile.$ext" + echo "$6" > $srcfile + echo " +int main () { return 0; } +" >> $srcfile + + local cmd="${!4} $cflags $(mkl_mkvar_get CPPFLAGS) -Wall -Werror $srcfile -o ${srcfile}.o $ldf $(mkl_mkvar_get LDFLAGS) $5"; + mkl_dbg "Compile check $1 ($2): $cmd" + + local output + output=$($cmd 2>&1) + + if [[ $? != 0 ]] ; then + mkl_dbg "compile check for $1 ($2) failed: $cmd: $output" + mkl_check_failed "$1" "$2" "$3" "compile check failed: +CC: $4 +flags: $5 +$cmd: +$output +source: $6" + local ret=1 + else + mkl_check_done "$1" "$2" "$3" "ok" + local ret=0 + fi + + # OSX XCode toolchain creates dSYM directories when -g is set, + # delete them specifically. + rm -rf "$srcfile" "${srcfile}.o" "$srcfile*dSYM" + + return $ret +} + + +# Try to link with a library. +# Arguments: +# config name +# define name +# action (fail|disable) +# linker flags (e.g. "-lpthreads") +function mkl_link_check { + mkl_check_begin "$1" "$2" "$3" "$1 (by linking)" && return $? + + local srcfile=$(mktemp _mktmpXXXXXX) + echo "int main () { return 0; }" > $srcfile + + local cmd="${CC} $(mkl_mkvar_get LDFLAGS) -c $srcfile -o ${srcfile}.o $4"; + mkl_dbg "Link check $1 ($2): $cmd" + + local output + output=$($cmd 2>&1) + + if [[ $? != 0 ]] ; then + mkl_dbg "link check for $1 ($2) failed: $output" + mkl_check_failed "$1" "$2" "$3" "compile check failed: +$output" + local ret=1 + else + mkl_check_done "$1" "$2" "$3" "ok" "$4" + local ret=0 + fi + + rm -f $srcfile* + return $ret +} + + + +# Tries to figure out if we can use a static library or not. +# Arguments: +# library name (e.g. -lrdkafka) +# compiler flags (optional "", e.g: "-lyajl") +# Returns/outputs: +# New list of compiler flags +function mkl_lib_check_static { + local libname=$1 + local libs=$2 + local arfile_var=STATIC_LIB_${libname#-l} + + mkl_dbg "Check $libname for static library (libs $libs, arfile variable $arfile_var=${!arfile_var})" + + # If STATIC_LIB_<libname_without_-l> specifies an existing .a file we + # use that instead. + if [[ -f ${!arfile_var} ]]; then + libs=$(echo $libs | sed -e "s|$libname|${!arfile_var}|g") + elif [[ $HAS_LDFLAGS_STATIC == y ]]; then + libs=$(echo $libs | sed -e "s|$libname|${LDFLAGS_STATIC} $libname ${LDFLAGS_DYNAMIC}|g") + else + mkl_dbg "$libname: Neither $arfile_var specified or static linker flags supported: static linking probably won't work" + fi + + echo $libs +} + + +# Checks that the specified lib is available through a number of methods. +# compiler flags are automatically appended to "LIBS" mkvar on success. +# +# If STATIC_LIB_<libname_without_-l> is set to the path of an <libname>.a file +# it will be used instead of -l<libname>. +# +# Arguments: +# [--static=<lib>] (allows static linking (--enable-static) for the +# library provided, e.g.: --static=-lrdkafka "librdkafka"..) +# [--libname=<lib>] (library name if different from config name, such as +# when the libname includes a dash) +# config name (library name (for pkg-config)) +# define name +# action (fail|disable|cont) +# compiler (CC|CXX) +# compiler flags (optional "", e.g: "-lyajl") +# source snippet +function mkl_lib_check { + + local is_static=0 + local staticopt= + if [[ $1 == --static* ]]; then + staticopt=$1 + shift + fi + + local libnameopt= + local libname=$1 + if [[ $1 == --libname* ]]; then + libnameopt=$1 + libname="${libnameopt#*=}" + shift + fi + + # pkg-config result (0=ok) + local pkg_conf_failed=1 + if [[ $WITH_PKGCONFIG == "y" ]]; then + # Let pkg-config populate CFLAGS, et.al. + mkl_pkg_config_check $staticopt $libnameopt "$1" "" cont + pkg_conf_failed=$? + fi + + local libs="" + if [[ $pkg_conf_failed ]]; then + libs="$5" + if [[ $WITH_STATIC_LINKING == y && ! -z $staticopt ]]; then + libs=$(mkl_lib_check_static "${staticopt#*=}" "$libs") + is_static=1 + fi + fi + + if ! mkl_compile_check "$1" "$2" "$3" "$4" "$libs" "$6"; then + return 1 + fi + + if [[ $pkg_conf_failed == 1 ]]; then + # Add libraries in reverse order to make sure inter-dependencies + # are resolved in the correct order. + # E.g., check for crypto and then ssl should result in -lssl -lcrypto + mkl_mkvar_prepend "$1" LIBS "$libs" + fi + + return 0 +} + + +# Check for library with pkg-config +# Automatically sets CFLAGS and LIBS from pkg-config information. +# Arguments: +# [--static=<lib>] (allows static linking (--enable-static) for the +# library provided, e.g.: --static=-lrdkafka "librdkafka"..) +# [--libname=<lib>] (library name if different from config name, such as +# when the libname includes a dash) +# config name +# define name +# action (fail|disable|ignore) +function mkl_pkg_config_check { + + local staticopt= + if [[ $1 == --static* ]]; then + staticopt=$1 + shift + fi + + local libname=$1 + if [[ $1 == --libname* ]]; then + libname="${libnameopt#*=}" + shift + fi + + local cname="${1}_PKGCONFIG" + mkl_check_begin "$cname" "$2" "no-cache" "$1 (by pkg-config)" && return $? + + local cflags= + local cmd="${PKG_CONFIG} --short-errors --cflags $libname" + mkl_dbg "pkg-config check $libname ($2): $cmd" + + cflags=$($cmd 2>&1) + if [[ $? != 0 ]]; then + mkl_dbg "'$cmd' failed: $cflags" + mkl_check_failed "$cname" "$2" "$3" "'$cmd' failed: +$cflags" + return 1 + fi + + local libs= + libs=$(${PKG_CONFIG} --short-errors --libs $libname 2>&1) + if [[ $? != 0 ]]; then + mkl_dbg "${PKG_CONFIG} --libs $libname failed: $libs" + mkl_check_failed "$cname" "$2" "$3" "pkg-config --libs failed" + return 1 + fi + + mkl_mkvar_append $1 "CFLAGS" "$cflags" + + if [[ $WITH_STATIC_LINKING == y && ! -z $staticopt ]]; then + libs=$(mkl_lib_check_static "${staticopt#*=}" "$libs") + fi + mkl_mkvar_prepend "$1" LIBS "$libs" + + mkl_check_done "$1" "$2" "$3" "ok" + + return 0 +} + + +# Check that a command runs and exits succesfully. +# Arguments: +# config name +# define name (optional, can be empty) +# action +# command +function mkl_command_check { + mkl_check_begin "$1" "$2" "$3" "$1 (by command)" && return $? + + local out= + out=$($4 2>&1) + if [[ $? != 0 ]]; then + mkl_dbg "$1: $2: $4 failed: $out" + mkl_check_failed "$1" "$2" "$3" "command '$4' failed: +$out" + return 1 + fi + + mkl_check_done "$1" "$2" "$3" "ok" + + return 0 +} + + +# Check that a program is executable, but will not execute it. +# Arguments: +# config name +# define name (optional, can be empty) +# action +# program name (e.g, objdump) +function mkl_prog_check { + mkl_check_begin --verb "checking executable" "$1" "$2" "$3" "$1" && return $? + + local out= + out=$(command -v "$4" 2>&1) + if [[ $? != 0 ]]; then + mkl_dbg "$1: $2: $4 is not executable: $out" + mkl_check_failed "$1" "$2" "$3" "$4 is not executable" + return 1 + fi + + mkl_check_done "$1" "$2" "$3" "ok" + + return 0 +} + + + + +# Checks that the check for the given config name passed. +# This does not behave like the other checks, if the given config name passed +# its test then nothing is printed. Else the configure will fail. +# Arguments: +# checked config name +function mkl_config_check { + local status=$(mkl_var_get "MKL_STATUS_$1") + [[ $status = "ok" ]] && return 0 + mkl_fail $1 "" "fail" "$MKL_MODULE requires $1" + return 1 +} + + +# Checks that all provided config names are set. +# Arguments: +# config name +# define name +# action +# check_config_name1 +# check_config_name2.. +function mkl_config_check_all { + local cname= + local res="ok" + echo start this now for $1 + for cname in ${@:4}; do + local st=$(mkl_var_get "MKL_STATUS_$cname") + [[ $status = "ok" ]] && continue + mkl_fail $1 $2 $3 "depends on $cname" + res="failed" + done + + echo "try res $res" + mkl_check_done "$1" "$2" "$3" $res +} + + +# Check environment variable +# Arguments: +# config name +# define name +# action +# environment variable +function mkl_env_check { + mkl_check_begin "$1" "$2" "$3" "$1 (by env $4)" && return $? + + if [[ -z ${!4} ]]; then + mkl_check_failed "$1" "$2" "$3" "environment variable $4 not set" + return 1 + fi + + mkl_check_done "$1" "$2" "$3" "ok" "${!4}" + + return 0 +} + + +# Run all checks +function mkl_checks_run { + # Set up common variables + mkl_allvar_set "" MKL_APP_NAME $(mkl_meta_get description name) + mkl_allvar_set "" MKL_APP_DESC_ONELINE "$(mkl_meta_get description oneline)" + + # Call checks functions in dependency order + local mf + for mf in $MKL_CHECKS ; do + MKL_MODULE=${mf%:*} + local func=${mf#*:} + + if mkl_func_exists $func ; then + $func + else + mkl_err "Check function $func from $MKL_MODULE disappeared ($mf)" + fi + unset MKL_MODULE + done +} + + +# Check for color support in terminal. +# If the terminal supports colors, the function will alter +# MKL_RED +# MKL_GREEN +# MKL_YELLOW +# MKL_BLUE +# MKL_CLR_RESET +function mkl_check_terminal_color_support { + local use_color=false + local has_tput=false + + if [[ -z ${TERM} ]]; then + # tput and dircolors require $TERM + mkl_dbg "\$TERM is not set! Cannot check for color support in terminal." + return 1 + elif hash tput 2>/dev/null; then + has_tput=true + [[ $(tput colors 2>/dev/null) -ge 8 ]] && use_color=true + mkl_dbg "tput reports color support: ${use_color}" + elif hash dircolors 2>/dev/null; then + # Enable color support only on colorful terminals. + # dircolors --print-database uses its own built-in database + # instead of using /etc/DIR_COLORS. Try to use the external file + # first to take advantage of user additions. + local safe_term=${TERM//[^[:alnum:]]/?} + local match_lhs="" + [[ -f ~/.dir_colors ]] && match_lhs="${match_lhs}$(<~/.dir_colors)" + [[ -f /etc/DIR_COLORS ]] && match_lhs="${match_lhs}$(</etc/DIR_COLORS)" + [[ -z ${match_lhs} ]] && match_lhs=$(dircolors --print-database) + [[ $'\n'${match_lhs} == *$'\n'"TERM "${safe_term}* ]] && use_color=true + mkl_dbg "dircolors reports color support: ${use_color}" + fi + + if ${use_color}; then + if ${has_tput}; then + # In theory, user could have set different escape sequences + # Because tput is available we can use it to query the right values ... + mkl_dbg "Using color escape sequences from tput" + MKL_RED=$(tput setaf 1) + MKL_GREEN=$(tput setaf 2) + MKL_YELLOW=$(tput setaf 3) + MKL_BLUE=$(tput setaf 4) + MKL_CLR_RESET=$(tput sgr0) + else + mkl_dbg "Using hard-code ANSI color escape sequences" + MKL_RED="\033[031m" + MKL_GREEN="\033[032m" + MKL_YELLOW="\033[033m" + MKL_BLUE="\033[034m" + MKL_CLR_RESET="\033[0m" + fi + else + mkl_dbg "Did not detect color support in \"$TERM\" terminal!" + fi + + return 0 +} + + + + +########################################################################### +# +# +# Module functionality +# +# +########################################################################### + +# Downloads module from repository. +# Arguments: +# module name +# Returns: +# module file name +function mkl_module_download { + local modname="$1" + local url="$MKL_REPO_URL/modules/configure.$modname" + local tmpfile="" + + fname="${MKLOVE_DIR}/modules/configure.$modname" + + if [[ $url != http*://* ]]; then + # Local path, just copy file. + if [[ ! -f $url ]]; then + mkl_err "Module $modname not found at $url" + return 1 + fi + + if ! cp "$url" "$fname" ; then + mkl_err "Failed to copy $url to $fname" + return 1 + fi + + echo "$fname" + return 0 + fi + + # Download + mkl_info "${MKL_BLUE}downloading missing module $modname from $url${MKL_CLR_RESET}" + + tmpfile=$(mktemp _mkltmpXXXXXX) + local out= + out=$(wget -nv -O "$tmpfile" "$url" 2>&1) + + if [[ $? -ne 0 ]]; then + rm -f "$tmpfile" + mkl_err "Failed to download $modname:" + mkl_err0 $out + return 1 + fi + + # Move downloaded file into place replacing the old file. + mv "$tmpfile" "$fname" || return 1 + + # "Return" filename + echo "$fname" + + return 0 +} + + +# Load module by name or filename +# Arguments: +# "require"|"try" +# filename +# [ module arguments ] +function mkl_module_load { + local try=$1 + shift + local fname=$1 + shift + local modname=${fname#*configure.} + local bypath=1 + + # Check if already loaded + if mkl_in_list "$MKL_MODULES" "$modname"; then + return 0 + fi + + if [[ $fname = $modname ]]; then + # Module specified by name, find the file. + bypath=0 + for fname in configure.$modname \ + ${MKLOVE_DIR}/modules/configure.$modname ; do + [[ -s $fname ]] && break + done + fi + + # Calling module + local cmod=$MKL_MODULE + [[ -z $cmod ]] && cmod="base" + + if [[ ! -s $fname ]]; then + # Attempt to download module, if permitted + if [[ $MKL_NO_DOWNLOAD != 0 || $bypath == 1 ]]; then + mkl_err "Module $modname not found at $fname (required by $cmod) and downloads disabled" + if [[ $try = "require" ]]; then + mkl_fail "$modname" "none" "fail" \ + "Module $modname not found (required by $cmod) and downloads disabled" + fi + return 1 + fi + + fname=$(mkl_module_download "$modname") + if [[ $? -ne 0 ]]; then + mkl_err "Module $modname not found (required by $cmod)" + if [[ $try = "require" ]]; then + mkl_fail "$modname" "none" "fail" \ + "Module $modname not found (required by $cmod)" + return 1 + fi + fi + + # Now downloaded, try loading the module again. + mkl_module_load $try "$fname" "$@" + return $? + fi + + # Set current module + local save_MKL_MODULE=$MKL_MODULE + MKL_MODULE=$modname + + mkl_dbg "Loading module $modname (required by $cmod) from $fname" + + # Source module file (positional arguments are available to module) + source $fname + + # Restore current module (might be recursive) + MKL_MODULE=$save_MKL_MODULE + + # Add module to list of modules + mkl_var_append MKL_MODULES $modname + + # Rename module's special functions so we can call them separetely later. + mkl_func_rename "options" "${modname}_options" + mkl_func_push MKL_CHECKS "$modname" "checks" + mkl_func_push MKL_GENERATORS "$modname" "generate" + mkl_func_push MKL_CLEANERS "$modname" "clean" +} + + +# Require and load module +# Must only be called from module file outside any function. +# Arguments: +# [ --try ] Dont fail if module doesn't exist +# module1 +# [ "must" "pass" ] +# [ module arguments ... ] +function mkl_require { + local try="require" + if [[ $1 = "--try" ]]; then + local try="try" + shift + fi + + local mod=$1 + shift + local override_action= + + # Check for cyclic dependencies + if mkl_in_list "$MKL_LOAD_STACK" "$mod"; then + mkl_err "Cyclic dependency detected while loading $mod module:" + local cmod= + local lmod=$mod + for cmod in $MKL_LOAD_STACK ; do + mkl_err " $lmod required by $cmod" + lmod=$cmod + done + mkl_fail base "" fail "Cyclic dependency detected while loading module $mod" + return 1 + fi + + mkl_var_prepend MKL_LOAD_STACK "$mod" + + + if [[ "$1 $2" == "must pass" ]]; then + shift + shift + override_action="fail" + fi + + if [[ ! -z $override_action ]]; then + mkl_meta_set "MOD__$mod" "override_action" "$override_action" + fi + + + mkl_module_load $try $mod "$@" + local ret=$? + + mkl_var_shift MKL_LOAD_STACK + + return $ret +} + + + +########################################################################### +# +# +# Usage options +# +# +########################################################################### + + +MKL_USAGE="Usage: ./configure [OPTIONS...] + + mklove configure script - mklove, not autoconf + Copyright (c) 2014-2015 Magnus Edenhill - https://github.com/edenhill/mklove +" + +function mkl_usage { + echo "$MKL_USAGE" + local name=$(mkl_meta_get description name) + + if [[ ! -z ${name} ]]; then + echo " $name - $(mkl_meta_get description oneline) + $(mkl_meta_get description copyright) +" + fi + + local og + for og in $MKL_USAGE_GROUPS ; do + og="MKL_USAGE_GROUP__$og" + echo "${!og}" + done + + echo "Honoured environment variables: + CC, CPP, CXX, CFLAGS, CPPFLAGS, CXXFLAGS, LDFLAGS, LIBS, + LD, NM, OBJDUMP, STRIP, PKG_CONFIG, PKG_CONFIG_PATH, + STATIC_LIB_<libname>=.../libname.a + +" + +} + + + +# Add usage option informative text +# Arguments: +# text +function mkl_usage_info { + MKL_USAGE="$MKL_USAGE +$1" +} + + +# Add option to usage output +# Arguments: +# option group ("Standard", "Cross-Compilation", etc..) +# variable name +# option ("--foo=feh") +# help +# default (optional) +# assignvalue (optional, default:"y") +# function block (optional) +function mkl_option { + local optgroup=$1 + local varname=$2 + + # Fixed width between option name and help in usage output + local pad=" " + if [[ ${#3} -lt ${#pad} ]]; then + pad=${pad:0:$(expr ${#pad} - ${#3})} + else + pad="" + fi + + # Add to usage output + local optgroup_safe=$(mkl_env_esc $optgroup) + if ! mkl_in_list "$MKL_USAGE_GROUPS" "$optgroup_safe" ; then + mkl_env_append MKL_USAGE_GROUPS "$optgroup_safe" + mkl_env_set "MKL_USAGE_GROUP__$optgroup_safe" "$optgroup options: +" + fi + + local defstr="" + [[ ! -z $5 ]] && defstr=" [$5]" + mkl_env_append "MKL_USAGE_GROUP__$optgroup_safe" " $3 $pad $4$defstr +" + + local optname="${3#--}" + local safeopt= + local optval="" + if [[ $3 == *=* ]]; then + optname="${optname%=*}" + optval="${3#*=}" + fi + + safeopt=$(mkl_env_esc $optname) + + mkl_meta_set "MKL_OPT_ARGS" "$safeopt" "$optval" + + # + # Optional variable scoping by prefix: "env:", "mk:", "def:" + # + local setallvar="mkl_allvar_set ''" + local setmkvar="mkl_mkvar_set ''" + + if [[ $varname = env:* ]]; then + # Set environment variable (during configure runtime only) + varname=${varname#*:} + setallvar=mkl_env_set + setmkvar=mkl_env_set + elif [[ $varname = mk:* ]]; then + # Set Makefile.config variable + varname=${varname#*:} + setallvar="mkl_mkvar_append ''" + setmkvar="mkl_mkvar_append ''" + elif [[ $varname = def:* ]]; then + # Set config.h define + varname=${varname#*:} + setallvar="mkl_define_set ''" + setmkvar="mkl_define_set ''" + fi + + + if [[ ! -z $7 ]]; then + # Function block specified. + eval "function opt_$safeopt { $7 }" + else + # Add default implementation of function simply setting the value. + # Application may override this by redefining the function after calling + # mkl_option. + if [[ $optval = "PATH" ]]; then + # PATH argument: make it an absolute path. + # Only set the make variable (not config.h) + eval "function opt_$safeopt { $setmkvar $varname \"\$(mkl_abspath \$(mkl_render \$1))\"; }" + else + # Standard argument: simply set the value + if [[ -z "$6" ]]; then + eval "function opt_$safeopt { $setallvar $varname \"\$1\"; }" + else + eval "function opt_$safeopt { $setallvar $varname \"$6\"; }" + fi + fi + fi + + # If default value is provided and does not start with "$" (variable ref) + # then set it right away. + # $ variable refs are set after all checks have run during the + # generating step. + if [[ ${#5} != 0 ]] ; then + if [[ $5 = *\$* ]]; then + mkl_var_append "MKL_LATE_VARS" "opt_$safeopt:$5" + else + opt_$safeopt $5 + fi + fi + + if [[ ! -z $varname ]]; then + # Add variable to list + MKL_CONFVARS="$MKL_CONFVARS $varname" + fi + +} + + + +# Adds a toggle (--enable-X, --disable-X) option. +# Arguments: +# option group ("Standard", ..) +# variable name (WITH_FOO) +# option (--enable-foo) +# help ("foo.." ("Enable" and "Disable" will be prepended)) +# default (y or n) + +function mkl_toggle_option { + + # Add option argument + mkl_option "$1" "$2" "$3" "$4" "$5" + + # Add corresponding "--disable-foo" option for "--enable-foo". + local disname="${3/--enable/--disable}" + local dishelp="${4/Enable/Disable}" + mkl_option "$1" "$2" "$disname" "$dishelp" "" "n" +} + +# Adds a toggle (--enable-X, --disable-X) option with builtin checker. +# This is the library version. +# Arguments: +# option group ("Standard", ..) +# config name (foo, must be same as pkg-config name) +# variable name (WITH_FOO) +# action (fail or disable) +# option (--enable-foo) +# help (defaults to "Enable <config name>") +# linker flags (-lfoo) +# default (y or n) + +function mkl_toggle_option_lib { + + local help="$6" + [[ -z "$help" ]] && help="Enable $2" + + # Add option argument + mkl_option "$1" "$3" "$5" "$help" "$8" + + # Add corresponding "--disable-foo" option for "--enable-foo". + local disname="${5/--enable/--disable}" + local dishelp="${help/Enable/Disable}" + mkl_option "$1" "$3" "$disname" "$dishelp" "" "n" + + # Create checks + eval "function _tmp_func { mkl_lib_check \"$2\" \"$3\" \"$4\" CC \"$7\"; }" + mkl_func_push MKL_CHECKS "$MKL_MODULE" _tmp_func +} + + + + + http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.builtin ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.builtin b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.builtin new file mode 100644 index 0000000..546cbb2 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.builtin @@ -0,0 +1,62 @@ +#!/bin/bash +# +# mklove builtin checks and options +# Sets: +# prefix, etc.. + + +mkl_option "Standard" prefix "--prefix=PATH" \ + "Install arch-independent files in PATH" "/usr/local" +mkl_option "Standard" exec_prefix "--exec-prefix=PATH" \ + "Install arch-dependent files in PATH" "\$prefix" +mkl_option "Standard" bindir "--bindir=PATH" "User executables" "\$exec_prefix/bin" +mkl_option "Standard" sbindir "--sbindir=PATH" "System admin executables" \ + "\$exec_prefix/sbin" +mkl_option "Standard" libexecdir "--libexecdir=PATH" "Program executables" \ + "\$exec_prefix/libexec" +mkl_option "Standard" datadir "--datadir=PATH" "Read-only arch-independent data" \ + "\$prefix/share" +mkl_option "Standard" sysconfdir "--sysconfdir=PATH" "Configuration data" \ + "\$prefix/etc" +mkl_option "Standard" sharedstatedir "--sharedstatedir=PATH" \ + "Modifiable arch-independent data" "\$prefix/com" +mkl_option "Standard" localstatedir "--localstatedir=PATH" \ + "Modifiable local state data" "\$prefix/var" +mkl_option "Standard" libdir "--libdir=PATH" "Libraries" "\$exec_prefix/lib" +mkl_option "Standard" includedir "--includedir=PATH" "C/C++ header files" \ + "\$prefix/include" +mkl_option "Standard" infodir "--infodir=PATH" "Info documentation" "\$prefix/info" +mkl_option "Standard" mandir "--mandir=PATH" "Manual pages" "\$prefix/man" + +mkl_option "Configure tool" "" "--list-modules" "List loaded mklove modules" +mkl_option "Configure tool" "" "--list-checks" "List checks" +mkl_option "Configure tool" env:MKL_FAILFATAL "--fail-fatal" "All failures are fatal" +mkl_option "Configure tool" env:MKL_NOCACHE "--no-cache" "Dont use or generate config.cache" +mkl_option "Configure tool" env:MKL_DEBUG "--debug" "Enable configure debugging" +mkl_option "Configure tool" env:MKL_CLEAN "--clean" "Remove generated configure files" +mkl_option "Configure tool" "" "--reconfigure" "Rerun configure with same arguments as last run" +mkl_option "Configure tool" env:MKL_NO_DOWNLOAD "--no-download" "Disable downloads of required mklove modules" +mkl_option "Configure tool" env:MKL_UPDATE_MODS "--update-modules" "Update modules from global repository" +mkl_option "Configure tool" env:MKL_REPO_URL "--repo-url=URL_OR_PATH" "Override mklove modules repo URL" "$MKL_REPO_URL" +mkl_option "Configure tool" "" "--help" "Show configure usage" + + +mkl_toggle_option "Compatibility" "mk:MKL_MAINT_MODE" "--enable-maintainer-mode" "Maintainer mode (no-op)" + +mkl_option "Configure tool" "mk:PROGRAM_PREFIX" "--program-prefix=PFX" "Program prefix" + +mkl_option "Compatibility" "mk:DISABL_DEP_TRACK" "--disable-dependency-tracking" "Disable dependency tracking (no-op)" +mkl_option "Compatibility" "mk:DISABL_SILENT_RULES" "--disable-silent-rules" "Verbose build output (no-op)" + + +function checks { + + if [[ ! -z $libdir ]]; then + mkl_mkvar_append "libdir" LDFLAGS "-L${libdir}" + fi + + if [[ ! -z $includedir ]]; then + mkl_mkvar_append "includedir" CPPFLAGS "-I${includedir}" + fi + +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cc ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cc b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cc new file mode 100644 index 0000000..30bddb1 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cc @@ -0,0 +1,178 @@ +#!/bin/bash +# +# Compiler detection +# Sets: +# CC, CXX, CFLAGS, CPPFLAGS, LDFLAGS, ARFLAGS, PKG_CONFIG, INSTALL, MBITS + + +mkl_require host + +function checks { + + # C compiler + mkl_meta_set "ccenv" "name" "C compiler from CC env" + if ! mkl_command_check "ccenv" "WITH_CC" cont "$CC --version"; then + if mkl_command_check "gcc" "WITH_GCC" cont "gcc --version"; then + CC=gcc + elif mkl_command_check "clang" "WITH_CLANG" cont "clang --version"; then + CC=clang + elif mkl_command_check "cc" "WITH_CC" fail "cc --version"; then + CC=cc + fi + fi + export CC="${CC}" + mkl_mkvar_set CC CC "$CC" + + if [[ $MKL_CC_WANT_CXX == 1 ]]; then + # C++ compiler + mkl_meta_set "cxxenv" "name" "C++ compiler from CXX env" + if ! mkl_command_check "cxxenv" "WITH_CXX" cont "$CXX --version" ; then + mkl_meta_set "gxx" "name" "C++ compiler (g++)" + mkl_meta_set "clangxx" "name" "C++ compiler (clang++)" + mkl_meta_set "cxx" "name" "C++ compiler (c++)" + if mkl_command_check "gxx" "WITH_GXX" cont "g++ --version"; then + CXX=g++ + elif mkl_command_check "clangxx" "WITH_CLANGXX" cont "clang++ --version"; then + CXX=clang++ + elif mkl_command_check "cxx" "WITH_CXX" fail "c++ --version"; then + CXX=c++ + fi + fi + export CXX="${CXX}" + mkl_mkvar_set "CXX" CXX "$CXX" + fi + + # Handle machine bits, if specified. + if [[ ! -z "$MBITS" ]]; then + mkl_meta_set mbits_m name "mbits compiler flag (-m$MBITS)" + if mkl_compile_check mbits_m "" fail CC "-m$MBITS"; then + mkl_mkvar_append CPPFLAGS CPPFLAGS "-m$MBITS" + mkl_mkvar_append LDFLAGS LDFLAGS "-m$MBITS" + fi + if [[ -z "$ARFLAGS" && $MBITS == 64 && $MKL_DISTRO == "SunOS" ]]; then + # Turn on 64-bit archives on SunOS + mkl_mkvar_append ARFLAGS ARFLAGS "S" + fi + fi + + # Provide prefix and checks for various other build tools. + local t= + for t in LD:ld NM:nm OBJDUMP:objdump STRIP:strip ; do + local tenv=${t%:*} + t=${t#*:} + local tval="${!tenv}" + + [[ -z $tval ]] && tval="$t" + + if mkl_prog_check "$t" "" disable "$tval" ; then + if [[ $tval != ${!tenv} ]]; then + export "$tenv"="$tval" + fi + mkl_mkvar_set $tenv $tenv "$tval" + fi + done + + # Compiler and linker flags + [[ ! -z $CFLAGS ]] && mkl_mkvar_set "CFLAGS" "CFLAGS" "$CFLAGS" + [[ ! -z $CPPFLAGS ]] && mkl_mkvar_set "CPPFLAGS" "CPPFLAGS" "$CPPFLAGS" + [[ ! -z $CXXFLAGS ]] && mkl_mkvar_set "CXXFLAGS" "CXXFLAGS" "$CXXFLAGS" + [[ ! -z $LDFLAGS ]] && mkl_mkvar_set "LDFLAGS" "LDFLAGS" "$LDFLAGS" + [[ ! -z $ARFLAGS ]] && mkl_mkvar_set "ARFLAGS" "ARFLAGS" "$ARFLAGS" + + if [[ $MKL_NO_DEBUG_SYMBOLS != "y" ]]; then + # Add debug symbol flag (-g) + # OSX 10.9 requires -gstrict-dwarf for some reason. + mkl_meta_set cc_g_dwarf name "debug symbols compiler flag (-g...)" + if [[ $MKL_DISTRO == "osx" ]]; then + if mkl_compile_check cc_g_dwarf "" cont CC "-gstrict-dwarf"; then + mkl_mkvar_append CPPFLAGS CPPFLAGS "-gstrict-dwarf" + else + mkl_mkvar_append CPPFLAGS CPPFLAGS "-g" + fi + else + mkl_mkvar_append CPPFLAGS CPPFLAGS "-g" + fi + fi + + + # pkg-config + if [ -z "$PKG_CONFIG" ]; then + PKG_CONFIG=pkg-config + fi + + if mkl_command_check "pkgconfig" "WITH_PKGCONFIG" cont "$PKG_CONFIG --version"; then + export PKG_CONFIG + fi + mkl_mkvar_set "pkgconfig" PKG_CONFIG $PKG_CONFIG + + [[ ! -z "$PKG_CONFIG_PATH" ]] && mkl_env_append PKG_CONFIG_PATH "$PKG_CONFIG_PATH" + + # install + if [ -z "$INSTALL" ]; then + if [[ $MKL_DISTRO == "SunOS" ]]; then + mkl_meta_set ginstall name "GNU install" + if mkl_command_check ginstall "" ignore "ginstall --version"; then + INSTALL=ginstall + else + INSTALL=install + fi + else + INSTALL=install + fi + fi + + if mkl_command_check "install" "WITH_INSTALL" cont "$INSTALL --version"; then + export INSTALL + fi + mkl_mkvar_set "install" INSTALL $INSTALL + + + # Enable profiling if desired + if [[ $WITH_PROFILING == y ]]; then + mkl_allvar_set "" "WITH_PROFILING" "y" + mkl_mkvar_append CPPFLAGS CPPFLAGS "-pg" + mkl_mkvar_append LDFLAGS LDFLAGS "-pg" + fi + + # Optimization + if [[ $WITHOUT_OPTIMIZATION == n ]]; then + mkl_mkvar_append CPPFLAGS CPPFLAGS "-O2" + else + mkl_mkvar_append CPPFLAGS CPPFLAGS "-O0" + fi + + # Static linking + if [[ $WITH_STATIC_LINKING == y ]]; then + # LDFLAGS_STATIC is the LDFLAGS needed to enable static linking + # of sub-sequent libraries, while + # LDFLAGS_DYNAMIC is the LDFLAGS needed to enable dynamic linking. + if [[ $MKL_DISTRO != "osx" ]]; then + mkl_mkvar_set staticlinking LDFLAGS_STATIC "-Wl,-Bstatic" + mkl_mkvar_set staticlinking LDFLAGS_DYNAMIC "-Wl,-Bdynamic" + mkl_mkvar_set staticlinking HAS_LDFLAGS_STATIC y + else + # OSX linker can't enable/disable static linking so we'll + # need to find the .a through STATIC_LIB_libname env var + mkl_mkvar_set staticlinking HAS_LDFLAGS_STATIC n + fi + fi +} + + +mkl_option "Compiler" "env:CC" "--cc=CC" "Build using C compiler CC" "\$CC" +mkl_option "Compiler" "env:CXX" "--cxx=CXX" "Build using C++ compiler CXX" "\$CXX" +mkl_option "Compiler" "ARCH" "--arch=ARCH" "Build for architecture" "$(uname -m)" +mkl_option "Compiler" "CPU" "--cpu=CPU" "Build and optimize for specific CPU" "generic" +mkl_option "Compiler" "MBITS" "--mbits=BITS" "Machine bits (32 or 64)" "" + +for n in CFLAGS CPPFLAGS CXXFLAGS LDFLAGS ARFLAGS; do + mkl_option "Compiler" "mk:$n" "--$n=$n" "Add $n flags" +done + +mkl_option "Compiler" "env:PKG_CONFIG_PATH" "--pkg-config-path" "Extra paths for pkg-config" + +mkl_option "Compiler" "WITH_PROFILING" "--enable-profiling" "Enable profiling" +mkl_option "Compiler" "WITH_STATIC_LINKING" "--enable-static" "Enable static linking" +mkl_option "Compiler" "WITHOUT_OPTIMIZATION" "--disable-optimization" "Disable optimization flag to compiler" "n" +mkl_option "Compiler" "env:MKL_NO_DEBUG_SYMBOLS" "--disable-debug-symbols" "Disable debugging symbols" "n" +mkl_option "Compiler" "env:MKL_WANT_WERROR" "--enable-werror" "Enable compiler warnings as errors" "n" http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cxx ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cxx b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cxx new file mode 100644 index 0000000..a38ac73 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.cxx @@ -0,0 +1,8 @@ +#!/bin/bash +# +# C++ detection +# +# This script simply limits the checks of configure.cc + + +MKL_CC_WANT_CXX=1 http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.fileversion ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.fileversion b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.fileversion new file mode 100644 index 0000000..9bea117 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.fileversion @@ -0,0 +1,65 @@ +#!/bin/bash +# +# Reads version from file and sets variables accordingly +# The first non-commented line in the file is expected to be the version string. +# Arguments: +# filename +# STR_VERSION_VARIABLE_NAME +# [ HEX_VERSION_VARIABLE_NAME ] +# +# Example: Set string version in variable named "MYVERSION_STR" and +# the hex representation in "MYVERSION" +# mkl_require VERSION.txt MYVERSION_STR MYVERSION + +if [[ -z "$2" ]]; then + mkl_fail "fileversion" "none" "fail" "Missing argument(s), expected: FILENAME STR_VER HEX_VER" + return 0 +fi + +fileversion_file="$1" +fileversion_strvar="$2" +fileversion_hexvar="$3" + +function checks { + mkl_check_begin "fileversion" "" "no-cache" "version from file $fileversion_file" + + if [[ ! -s $fileversion_file ]]; then + mkl_check_failed "fileversion" "" "fail" \ + "Version file $fileversion_file is not readable" + return 1 + fi + + local orig=$(grep -v ^\# "$fileversion_file" | grep -v '^$' | head -1) + # Strip v prefix if any + orig=${orig#v} + + # Try to decode version string into hex + # Supported format is "[v]NN.NN.NN[.NN]" + if [[ ! -z $fileversion_hexvar ]]; then + local hex="" + local s=${orig#v} # Strip v prefix, if any. + local ncnt=0 + local n= + for n in ${s//./ } ; do + if [[ ! ( "$n" =~ ^[0-9][0-9]?$ ) ]]; then + mkl_check_failed "fileversion" "" "fail" \ + "$fileversion_file: Could not decode '$orig' into hex version, expecting format 'NN.NN.NN[.NN]'" + return 1 + fi + hex="$hex$(printf %02x $n)" + ncnt=$(expr $ncnt + 1) + done + + if [[ ! -z $hex ]]; then + # Finish all four bytess + for n in {$ncnt..4} ; do + hex="$hex$(printf %02x 0)" + done + mkl_allvar_set "fileversion" "$fileversion_hexvar" "0x$hex" + fi + fi + + mkl_allvar_set "fileversion" "$fileversion_strvar" "$orig" + + mkl_check_done "fileversion" "" "cont" "ok" "${!fileversion_strvar}" +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.gitversion ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.gitversion b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.gitversion new file mode 100644 index 0000000..b6ac486 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.gitversion @@ -0,0 +1,19 @@ +#!/bin/bash +# +# Sets version variable from git information. +# Optional arguments: +# "as" +# VARIABLE_NAME +# +# Example: Set version in variable named "MYVERSION": +# mkl_require gitversion as MYVERSION + +if [[ $1 == "as" ]]; then + __MKL_GITVERSION_VARNAME="$2" +else + __MKL_GITVERSION_VARNAME="VERSION" +fi + +function checks { + mkl_allvar_set "gitversion" "$__MKL_GITVERSION_VARNAME" "$(git describe --abbrev=6 --tags HEAD --always)" +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.good_cflags ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.good_cflags b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.good_cflags new file mode 100644 index 0000000..c8587f2 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.good_cflags @@ -0,0 +1,18 @@ +#!/bin/bash +# +# Provides some known-good CFLAGS +# Sets: +# CFLAGS +# CXXFLAGS +# CPPFLAGS + + +function checks { + mkl_mkvar_append CPPFLAGS CPPFLAGS \ + "-Wall -Wsign-compare -Wfloat-equal -Wpointer-arith -Wcast-align" + + if [[ $MKL_WANT_WERROR = "y" ]]; then + mkl_mkvar_append CPPFLAGS CPPFLAGS \ + "-Werror" + fi +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.host ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.host b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.host new file mode 100644 index 0000000..4dfdce8 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.host @@ -0,0 +1,110 @@ +#!/bin/bash +# +# Host OS support +# Sets: +# HOST +# BUILD +# TARGET + +# FIXME: No need for this right now +#mkl_require host_linux +#mkl_require host_osx +#mkl_require host_cygwin + +#mkl_option "Cross-compilation" "mk:HOST_OS" "--host-os=osname" "Host OS (linux,osx,cygwin,..)" "auto" + + +# autoconf compatibility - does nothing at this point +mkl_option "Cross-compilation" "mk:HOST" "--host=HOST" "Configure to build programs to run on HOST (no-op)" +mkl_option "Cross-compilation" "mk:BUILD" "--build=BUILD" "Configure for building on BUILD (no-op)" +mkl_option "Cross-compilation" "mk:TARGET" "--target=TARGET" "Configure for building cross-toolkits for platform TARGET (no-op)" + +function checks { + # Try to figure out what OS/distro we are running on. + mkl_check_begin "distro" "" "no-cache" "OS or distribution" + + solib_ext=.so + + # Try lsb_release + local sys + sys=$(lsb_release -is 2>/dev/null) + if [[ $? -gt 0 ]]; then + # That didnt work, try uname. + local kn=$(uname -s) + case $kn in + Linux) + sys=Linux + solib_ext=.so + ;; + Darwin) + sys=osx + solib_ext=.dylib + ;; + CYGWIN*) + sys=Cygwin + solib_ext=.dll + ;; + *) + sys="$kn" + solib_ext=.so + ;; + esac + fi + + if [[ -z $sys ]]; then + mkl_check_failed "distro" "" "ignore" "" + else + mkl_check_done "distro" "" "ignore" "ok" "$sys" + mkl_mkvar_set "distro" "MKL_DISTRO" "$sys" + mkl_allvar_set "distro" "SOLIB_EXT" "$solib_ext" + fi +} + +#function checks { +# mkl_check_begin "host" "HOST_OS" "no-cache" "host OS" +# +# # +# # If --host-os=.. was not specified then this is most likely not a +# # a cross-compilation and we can base the host-os on the native OS. +# # +# if [[ $HOST_OS != "auto" ]]; then +# mkl_check_done "host" "HOST_OS" "cont" "ok" "$HOST_OS" +# return 0 +# fi +# +# kn=$(uname -s) +# case $kn in +# Linux) +# hostos=linux +# ;; +# Darwin) +# hostos=osx +# ;; +# CYGWIN*) +# hostos=cygwin +# ;; +# *) +# hostos="$(mkl_lower $kn)" +# mkl_err "Unknown host OS kernel name: $kn" +# mkl_err0 " Will attempt to load module host_$hostos anyway." +# mkl_err0 " Please consider writing a configure.host_$hostos" +# ;; +# esac +# +# if ! mkl_require --try "host_$hostos"; then +# # Module not found +# mkl_check_done "host" "HOST_OS" "cont" "failed" "$kn?" +# else +# # Module loaded +# +# if mkl_func_exists "host_${hostos}_setup" ; then +# "host_${hostos}_setup" +# fi +# +# mkl_check_done "host" "HOST_OS" "cont" "ok" "$hostos" +# fi +# +# # Set HOST_OS var even if probing failed. +# mkl_mkvar_set "host" "HOST_OS" "$hostos" +#} + http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.lib ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.lib b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.lib new file mode 100644 index 0000000..49ed293 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.lib @@ -0,0 +1,49 @@ +#!/bin/bash +# +# Module for building shared libraries +# Sets: +# WITH_GNULD | WITH_OSXLD +# WITH_LDS - linker script support +mkl_require pic + +function checks { + + mkl_mkvar_append LIB_LDFLAGS LIB_LDFLAGS '-shared' + + # Check what arguments to pass to CC or LD for shared libraries + mkl_meta_set gnulib name "GNU-compatible linker options" + mkl_meta_set osxlib name "OSX linker options" + + if mkl_compile_check gnulib WITH_GNULD cont CC \ + "-shared -Wl,-soname,mkltest.0" "" ; then + # GNU linker + mkl_mkvar_append LIB_LDFLAGS LIB_LDFLAGS '-Wl,-soname,$(LIBFILENAME)' + + elif mkl_compile_check osxlib WITH_OSXLD cont CC \ + "-dynamiclib -Wl,-install_name,/tmp/mkltest.so.0" ; then + # OSX linker + mkl_mkvar_append LIB_LDFLAGS LIB_LDFLAGS '-dynamiclib -Wl,-install_name,$(DESTDIR)$(libdir)/$(LIBFILENAME)' + fi + + # Check what argument is needed for passing linker script. + local ldsfile=$(mktemp _mkltmpXXXXXX) + echo "{ + global: + *; +}; +" > $ldsfile + + mkl_meta_set ldsflagvs name "GNU linker-script ld flag" + mkl_meta_set ldsflagm name "Solaris linker-script ld flag" + if mkl_compile_check ldsflagvs "" cont CC \ + "-shared -Wl,--version-script=$ldsfile"; then + mkl_mkvar_set ldsflagvs LDFLAG_LINKERSCRIPT "-Wl,--version-script=" + mkl_mkvar_set lib_lds WITH_LDS y + elif mkl_compile_check ldsflagm "" ignore CC \ + "-shared -Wl,-M$ldsfile"; then + mkl_mkvar_set ldsflagm LDFLAG_LINKERSCRIPT "-Wl,-M" + mkl_mkvar_set lib_lds WITH_LDS y + fi + + rm -f "$ldsfile" +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.parseversion ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.parseversion b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.parseversion new file mode 100644 index 0000000..0ee0f57 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.parseversion @@ -0,0 +1,95 @@ +#!/bin/bash +# +# Parses the provided version string and creates variables accordingly. +# [ "hex2str" <fmt> ] -- version-string is in hex (e.g., 0x00080300) +# version-string +# STR_VERSION_VARIABLE_NAME +# [ HEX_VERSION_VARIABLE_NAME ] +# +# Note: The version will also be set in MKL_APP_VERSION +# +# Example: Set string version in variable named "MYVERSION_STR" and +# the hex representation in "MYVERSION" +# mkl_require parseversion "$(head -1 VERSION.txt)" MYVERSION_STR MYVERSION + +if [[ $1 == "hex2str" ]]; then + parseversion_type="hex" + parseversion_fmt="${2}:END:%d%d%d%d" + shift + shift +else + parseversion_type="" + parseversion_fmt="%d.%d.%d.%d" +fi + +if [[ -z "$2" ]]; then + mkl_fail "parseversion" "none" "fail" "Missing argument(s)" + return 0 +fi + +parseversion_orig="$1" +parseversion_strvar="$2" +parseversion_hexvar="$3" + +function checks { + mkl_check_begin --verb "parsing" "parseversion" "" "no-cache" \ + "version '$parseversion_orig'" + + # Strip v prefix if any + orig=${parseversion_orig#v} + + if [[ $orig == 0x* ]]; then + parseversion_type="hex" + orig=${orig#0x} + fi + + if [[ -z $orig ]]; then + mkl_check_failed "parseversion" "" "fail" "Version string is empty" + return 1 + fi + + # If orig is in hex we construct a string format instead. + if [[ $parseversion_type == "hex" ]]; then + local s=$orig + local str="" + local vals="" + while [[ ! -z $s ]]; do + local n=${s:0:2} + s=${s:${#n}} + vals="${vals}$(printf %d 0x$n) " + done + str=$(printf "$parseversion_fmt" $vals) + orig=${str%:END:*} + fi + + + # Try to decode version string into hex + # Supported format is "[v]NN.NN.NN[.NN]" + if [[ ! -z $parseversion_hexvar ]]; then + local hex="" + local s=$orig + local ncnt=0 + local n= + for n in ${s//./ } ; do + if [[ ! ( "$n" =~ ^[0-9][0-9]?$ ) ]]; then + mkl_check_failed "parseversion" "" "fail" \ + "Could not decode '$parseversion_orig' into hex version, expecting format 'NN.NN.NN[.NN]'" + return 1 + fi + hex="$hex$(printf %02x $n)" + ncnt=$(expr $ncnt + 1) + done + + if [[ ! -z $hex ]]; then + # Finish all four bytess + while [[ ${#hex} -lt 8 ]]; do + hex="$hex$(printf %02x 0)" + done + mkl_allvar_set "parseversion" "$parseversion_hexvar" "0x$hex" + fi + fi + + mkl_allvar_set "parseversion" "$parseversion_strvar" "$orig" + mkl_allvar_set "parseversion" MKL_APP_VERSION "$orig" + mkl_check_done "parseversion" "" "cont" "ok" "${!parseversion_strvar}" +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.pic ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.pic b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.pic new file mode 100644 index 0000000..8f138f8 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.pic @@ -0,0 +1,16 @@ +#!/bin/bash +# +# Checks if -fPIC is supported, and if so turns it on. +# +# Sets: +# HAVE_PIC +# CPPFLAGS +# + +function checks { + + if mkl_compile_check PIC HAVE_PIC disable CC "-fPIC" "" ; then + mkl_mkvar_append CPPFLAGS CPPFLAGS "-fPIC" + fi +} + http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/mklove/modules/configure.socket ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/mklove/modules/configure.socket b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.socket new file mode 100644 index 0000000..f0777ab --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/mklove/modules/configure.socket @@ -0,0 +1,20 @@ +#!/bin/bash +# +# Provides proper compiler flags for socket support, e.g. socket(3). + +function checks { + + local src=" +#include <sys/types.h> +#include <sys/socket.h> +#include <unistd.h> +void foo (void) { + int s = socket(0, 0, 0); + close(s); +}" + if ! mkl_compile_check socket "" cont CC "" "$src"; then + if mkl_compile_check --ldflags="-lsocket -lnsl" socket_nsl "" fail CC "" "$src"; then + mkl_mkvar_append socket_nsl LIBS "-lsocket -lnsl" + fi + fi +} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/packaging/RELEASE.md ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/packaging/RELEASE.md b/thirdparty/librdkafka-0.11.4/packaging/RELEASE.md new file mode 100644 index 0000000..70d4519 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/packaging/RELEASE.md @@ -0,0 +1,137 @@ +# librdkafka release process + +This guide outlines the steps needed to release a new version of librdkafka +and publish packages to channels (NuGet, Homebrew, etc,..). + +Releases are done in two phases: + * release-candidate(s) - RC1 will be the first release candidate, and any + changes to the repository will require a new RC. + * final release - the final release is based directly on the last RC tag + followed by a single version-bump commit (see below). + +Release tag and version format: + * release-candidate: vA.B.C-RCn + * final release: vA.B.C + + + +## Run regression tests + +**Build tests:** + + $ cd tests + $ make -j build + +**Run the full regression test suite:** (requires Linux and the trivup python package) + + $ make full + + +If all tests pass, carry on, otherwise identify and fix bug and start over. + + +## Pre-release code tasks + +**Switch to the release branch which is of the format `A.B.C.x` or `A.B.x`.** + + $ git checkout -b 0.11.1.x + + +**Update in-code versions.** + +The last octet in the version hex number is the pre-build/release-candidate +number, where 0xAABBCCff is the final release for version 0xAABBCC. +Release candidates start at 200, thus 0xAABBCCc9 is RC1, 0xAABBCCca is RC2, etc. + +Change the `RD_KAFKA_VERSION` defines in both `src/rdkafka.h` and +`src-cpp/rdkafkacpp.h` to the version to build, such as 0x000b01c9 +for v0.11.1-RC1, or 0x000b01ff for the final v0.11.1 release. + + # Update defines + $ $EDITOR src/rdkafka.h src-cpp/rdkafkacpp.h + + # Reconfigure and build + $ ./configure + $ make + + # Check git diff for correctness + $ git diff + + # Commit + $ git commit -m "Version v0.11.1-RC1" src/rdkafka.h src-cpp/rdkafkacpp.h + + +**Create tag.** + + $ git tag v0.11.1-RC1 # for an RC + # or for the final release: + $ git tag v0.11.1 # for the final release + + +**Push branch and commit to github** + + # Dry-run first to make sure things look correct + $ git push --dry-run origin 0.11.1.x + + # Live + $ git push origin 0.11.1.x +**Push tags and commit to github** + + # Dry-run first to make sure things look correct. + $ git push --dry-run --tags origin v0.11.1-RC1 + + # Live + $ git push --tags origin v0.11.1-RC1 + + + +## Creating packages + +As soon as a tag is pushed the CI systems (Travis and AppVeyor) will +start their builds and eventually upload the packaging artifacts to S3. +Wait until this process is finished by monitoring the two CIs: + + * https://travis-ci.org/edenhill/librdkafka + * https://ci.appveyor.com/project/edenhill/librdkafka + + +### Create NuGet package + +On a Linux host with docker installed, this will also require S3 credentials +to be set up. + + $ cd packaging/nuget + $ pip install -r requirements.txt # if necessary + $ ./release.py v0.11.1-RC1 + +Test the generated librdkafka.redist.0.11.1-RC1.nupkg and +then upload it to NuGet manually: + + * https://www.nuget.org/packages/manage/upload + + +### Homebrew recipe update + +The brew-update-pr.sh script automatically pushes a PR to homebrew-core +with a patch to update the librdkafka version of the formula. +This should only be done for final releases and not release candidates. + +On a MacOSX host with homebrew installed: + + $ cd package/homebrew + # Dry-run first to see that things are okay. + $ ./brew-update-pr.sh v0.11.1 + # If everything looks good, do the live push: + $ ./brew-update-pr.sh --upload v0.11.1 + + +### Deb and RPM packaging + +Debian and RPM packages are generated by Confluent packaging in a separate +process and the resulting packages are made available on Confluent's +APT and YUM repositories. + +That process is outside the scope of this document. + +See the Confluent docs for instructions how to access these packages: +https://docs.confluent.io/current/installation.html http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/packaging/archlinux/PKGBUILD ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/packaging/archlinux/PKGBUILD b/thirdparty/librdkafka-0.11.4/packaging/archlinux/PKGBUILD new file mode 100644 index 0000000..9321698 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/packaging/archlinux/PKGBUILD @@ -0,0 +1,5 @@ +pkgname=librdkafka +pkgver=master +pkgrel=1 +pkgdesc=The Apache Kafka C/C++ client library +arch=('i686' 'x86_64') http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7528d23e/thirdparty/librdkafka-0.11.4/packaging/cmake/Config.cmake.in ---------------------------------------------------------------------- diff --git a/thirdparty/librdkafka-0.11.4/packaging/cmake/Config.cmake.in b/thirdparty/librdkafka-0.11.4/packaging/cmake/Config.cmake.in new file mode 100644 index 0000000..ef9e067 --- /dev/null +++ b/thirdparty/librdkafka-0.11.4/packaging/cmake/Config.cmake.in @@ -0,0 +1,20 @@ +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) + +if(@WITH_ZLIB@) + find_dependency(ZLIB) +endif() + +if(@WITH_SSL@) + if(@WITH_BUNDLED_SSL@) + # TODO: custom SSL library should be installed + else() + find_dependency(OpenSSL) + endif() +endif() + +find_dependency(Threads) + +include("${CMAKE_CURRENT_LIST_DIR}/@[email protected]") +check_required_components("@PROJECT_NAME@")
