Configure.om

# It is recommended that these function be used from an appropriate static. block 

open build/Common


ConfMsgChecking(msg) =
    print($"--- Checking $(msg)... ")

ConfMsgResult(msg) =
    println($"($(msg))")
    value $(msg)

ConfMsgWarn(msg) =
    msg[] = $(split $(nl), $(msg))
    print($(concat $(EMPTY), $(add-wrapper $'--- *** ', $(nl), $(msg))))

ConfMsgError(msg) =
    msg[] = $(split $(nl), $(msg))
    eprintln($"""*** ERROR: $(concat '$(nl)---        ', $(msg))""")
    exit(1)
  
# flag = $(ConfMsgYesNo <bool expr>)
# flag = $(ConfMsgFound <bool expr>)

# The ConfMsgFound function expects to receive a boolean flag describing whether a test
# previously announced using the ConfMsgChecking found what it
# was looking for. ConfMsgFound will output the appropriate result (``found'' or ``NOT found'')
# using the ConfMsgResult and return its argument back.

# The ConfMsgYesNo function is similar, outputting a simple (``yes'' or ``NO'').

ConfMsgYesNo(found) =
   ConfMsgResult($(if $(found), yes, NO))
   return $(found)

ConfMsgFound(found) =
   ConfMsgResult($(if $(found), found, NOT found))
   return $(found)
   

# TryCompileC{TryRunC}

# success = $(TryCompileC <prog_text>)
# success = $(TryLinkC <prog_text>)
# success = $(TryRunC <prog_text>)

#
# Given the text of a C program, the TryCompileC, TryLinkC, and TryRunC
# functions would try to compile / compile and link / compile, link, and run, the given program and return a boolean flag
# indicating whether the attempt was successful.
#
# TryCompileC will use the CC, CFLAGS and INCLUDES variables 
# to run the C compiler. TryLinkC and TryRunC will also use the LDFLAGS
# to run the C compiler and linker. However, the flags like \verb+/WX+, \verb+-Werror+ and \verb+-warn-error+
# will be not be passed to the compiler, even if they occur in CFLAGS.
#
# These functions are silent and should normally be used with an appropriate
# ConfMsgChecking $\ldots$ ConfMsgResult.
# doc

ConfCleanCFLAGS(cflags) =
    value $(filter-out /WX -Werror --warn-error, $(cflags))

TryCompilingC(command, command_suffix, ext, prog, extra) =
    # The command line
    private.tmp_c = $(file $(tmpfile omake, .c))
    private.tmp = $(file $(replacesuffixes .c, $"$(EMPTY)", $(tmp_c)))

    export command
    if $(and $(not $(equal $(CCOUT), $(LDOUT))), $(equal $(ext), $(EXE)))
        command[] += $(CCOUT)$(file $(tmp)$(EXT_OBJ)) $(LDOUT)$(file $(tmp)$(ext))
    else
        command[] += $(CCOUT)$(file $(tmp)$(ext))

    command[] += $(file $(tmp_c)) $(command_suffix)

    # The program
    program = $"""/* Configuration file; you can remove this. */
/* Command line: $(command) */
$(prog)
"""
    
    # Compile it
    fprint($(tmp_c), $(program))
    protected.result = $(shell-success-null $(command))

    export result
    if $(result)
        switch $(extra)
        case Runs
            result = $(shell-success-null $(file $(tmp)$(EXE)))
        case Output
            result =
                try
                    value $(shell $(file $(tmp)$(EXE)))
                default
                    value $(not true)

    # Remove temporaries
    rm -f $(tmp_c) $(tmp)$(EXT_OBJ) $(tmp)$(EXE)

    return $(result)

TryCompileC(prog) =
    return $(TryCompilingC $(CC) $(ConfCleanCFLAGS $(CFLAGS)) $(PREFIXED_INCLUDES) -c, $(EMPTY), $(EXT_OBJ), $(prog), None)

TryLinkC(prog) =
    return $(TryCompilingC $(CC) $(ConfCleanCFLAGS $(CFLAGS)) $(PREFIXED_INCLUDES), $(LDFLAGS), $(EXE), $(prog), None)

TryRunC(prog) =
    return $(TryCompilingC $(CC) $(ConfCleanCFLAGS $(CFLAGS)) $(PREFIXED_INCLUDES), $(LDFLAGS), $(EXE), $(prog), Runs)


# RunCProg

# output = $(RunCProg <prog>)

#
# RunCProg is similar to the RunCProg, except that it
# returns the output of the function (will return false if the program fails to compile
# or run).


RunCProg(prog) =
    return $(TryCompilingC $(CC) $(ConfCleanCFLAGS $(CFLAGS)) $(PREFIXED_INCLUDES), $(LDFLAGS), $(EXE), $(prog), Output)

#
# Check whether a header file exists.
# We call the C compiler.
#
# doc
# CheckCHeader
# verbatim
# success = $(CheckCHeader <files>)
# success = $(VerboseCheckCHeader <files>)
# verbatim
#
# Use the TryCompileC to check whether your C compiler can locate
# and process the specified headers files.
# Will incude \verb+<stdio.h>+ before including the header files.
#
# Both functions return a boolean value. The CheckCHeader function is silent; the
# VerboseCheckCHeader function will use the ConfMsgChecking and
# ConfMsgResult functions to describe the test and the outcome.
#
# Example:
# verbatim
# static. =
#    NCURSES_H_AVAILABLE = $(VerboseCheckCHeader ncurses.h)
# verbatim
# doc
#
public.CheckCHeader(files) =
    return $(TryCompileC $"""
#ifdef __cplusplus
extern "C"
#endif
#pragma warning( disable : 4100 )
#include <stdio.h>
$(add-wrapper $(nl)$'#include <', >, $(files))
int main(int argc, char **argv) {
    return 0;
}
""")

public.VerboseCheckCHeader(files) =
    ConfMsgChecking(for $(files))
    return $(ConfMsgFound $(CheckCHeader $(files)))

#
# Check whether the libraries have the given functions
#
# doc
# CheckCLib
# verbatim
# success = $(CheckCLib <libs>, <functions>)
# success = $(VerboseCheckCLib <libs>, <functions>)
# verbatim
#
# Use the TryLinkC to check whether your C compiler and linker can
# find the named functions when linking with the named libraries.  Will pass the \verb+<libs>+ to
# the compiler using the \verb+-l+ flag.
#
# Both functions return a boolean value. The CheckCLib function is silent; the
# VerboseCheckCHeader function will use the ConfMsgChecking and
# ConfMsgResult functions to describe the test and the outcome.
#
# Example:
# verbatim
# static. =
#     NCURSES_LIB_AVAILABLE = $(VerboseCheckCLib ncurses, initscr setupterm tigetstr)
# verbatim
# doc
#
public.CheckCLib(libs, funs) =
    CFLAGS += $(addprefix -l, $(libs))

    return $(TryLinkC $"""
#ifdef __cplusplus
extern "C"
#endif
#pragma warning( disable : 4100 )
/* Override any gcc2 internal prototype to avoid an error.  */
$(add-wrapper $(nl)extern char , $'();', $(funs))
int main(int argc, char **argv) {
    /* Usage */
$(add-wrapper $(nl)    , $'();', $(funs))
    return 0;
}
""")

public.VerboseCheckCLib(libs, funs) =
    msg1 = $(if $(funs), $"""function$(if $(gt $(length $(funs)), 1), s) $(concat $", ", $(funs))""")
    msg2 = $(if $(libs), $"""librar$(if $(gt $(length $(libs)), 1), ies, y) $(concat $", ", $(libs))""")
    ConfMsgChecking($"""for $(msg1)$(if $(not $(or $(not $(funs)), $(not $(libs)))), $' in ')$(msg2)""")
    return $(ConfMsgFound $(CheckCLib $(libs), $(funs)))

#
# Backwards compatibility
#
# XXX: Once we decide how we are going to provide the multi-language support,
#      we should either update these or have them produce an "obsolete" warning.
#
public.CheckLib = $(CheckCLib)
public.VerboseCheckLib = $(VerboseCheckCLib)
public.CheckHeader = $(CheckCHeader)
public.VerboseCheckHeader = $(VerboseCheckCHeader)

#
# Check whether a program exists in the PATH
#
# doc
# CheckProg
# \verb+success = $(CheckProg <prog>)+
#
# Checks whether the program \verb+<prog>+ exists in your path. Will use the
# ConfMsgChecking and
# ConfMsgResult functions to describe the test and the outcome.
#

#
public.CheckProg(prog) =
   ConfMsgChecking(for $(prog))
   WHERE = $(where $(prog))
   if $(WHERE)
      ConfMsgResult(found $(nth 0, $(WHERE)))
      return true
   else
      ConfMsgResult(FAILED - no $(prog) found)
      return false

#

# \section{Translating autoconf scripts}
# Some of the functions described above are very similar to the ones present in autoconf.
# Below is a brief translation table for such functions.
# description
# \itemidx{AC\_MSG\_CHECKING} is very similar to ConfMsgChecking.
# \itemidx{AC\_MSG\_RESULT} is very similar to ConfMsgResult.
# \itemidx{AC\_MSG\_WARN} is very similar to ConfMsgWarn.
# \itemidx{AC\_MSG\_ERROR} is very similar to ConfMsgError.
# \itemidx{AC\_TRY\_COMPILE} is somewhat similar to TryCompileC,
#     except the TryCompileC returns a boolean value and only works for C. Similarly,
# \itemidx{AC\_TRY\_LINK} is approximated by TryLinkC, and
# \itemidx{AC\_TRY\_RUN} is approximated by TryRunC.
# description
#
# \section{Predefined configuration tests}
# A number of configuration tests are already included in the standard library.
# In order to use them in your project, simply open (see Section~\ref{section:include}) the
# corresponding build file in your OMakefile and the tests will run the first time \OMake{}
# is executed. Note that it is not a problem to open these files from more than one place in
# your project --- if you do that, the test will still run only once.

#