ucx: make/toolchain.sh@b0c4750cecd8

     1 #!/bin/sh

2 #

     3 # toolchain detection

4 #

     6 if isplatform "bsd" && notisplatform "openbsd"; then

     7   C_COMPILERS="clang gcc cc"

     8   CPP_COMPILERS="clang++ g++ CC"

     9 else

    10   C_COMPILERS="gcc clang suncc cc"

    11   CPP_COMPILERS="g++ clang++ sunCC CC"

    12 fi

    13 unset TOOLCHAIN

    14 unset TOOLCHAIN_NAME

    15 unset TOOLCHAIN_CC

    16 unset TOOLCHAIN_CXX

    18 check_c_compiler()

    19 {

    20   cat > "$TEMP_DIR/test.c" << __EOF__

    21 /* test file */

    22 #include <stdio.h>

    23 int main(int argc, char **argv) {

    24 #if defined(_MSC_VER)

    25   printf("msc\n");

    26 #elif defined(__clang__)

    27   printf("clang gnuc\n");

    28 #elif defined(__GNUC__)

    29   printf("gcc gnuc\n");

    30 #elif defined(__sun)

    31   printf("suncc\n");

    32 #else

    33   printf("unknown\n");

    34 #endif

    35   return 0;

    36 }

    37 __EOF__

    38   rm -f "$TEMP_DIR/checkcc"

    39   $1 -o "$TEMP_DIR/checkcc" $CFLAGS $LDFLAGS "$TEMP_DIR/test.c" 2> /dev/null

    40 }

    42 check_cpp_compiler()

    43 {

    44   cat > "$TEMP_DIR/test.cpp" << __EOF__

    45 /* test file */

    46 #include <iostream>

    47 int main(int argc, char **argv) {

    48 #if defined(_MSC_VER)

    49   std::cout << "msc" << std::endl;

    50 #elif defined(__clang__)

    51   std::cout << "clang gnuc" << std::endl;

    52 #elif defined(__GNUC__)

    53   std::cout << "gcc gnuc" << std::endl;

    54 #elif defined(__sun)

    55   std::cout << "suncc" << std::endl;

    56 #else

    57   std::cout << "cc" << std::endl;

    58 #endif

    59   return 0;

    60 }

    61 __EOF__

    62   rm -f "$TEMP_DIR/checkcc"

    63   $1 -o "$TEMP_DIR/checkcc" $CXXFLAGS $LDFLAGS "$TEMP_DIR/test.cpp" 2> /dev/null

    64 }

    66 create_libtest_source()

    67 {

    68   # $1: filename

    69   # $2: optional include

    70   cat > "$TEMP_DIR/$1" << __EOF__

    71 /* libtest file */

    72 int main(int argc, char **argv) {

    73   return 0;

    74 }

    75 __EOF__

    76   if [ -n "$2" ]; then

    77     echo "#include <$2>" >> "$TEMP_DIR/$1"

    78   fi

    79 }

    81 check_c_lib()

    82 {

    83   # $1: libname

    84   # $2: optional include

    85   if [ -z "$TOOLCHAIN_CC" ]; then

    86     return 1

    87   fi

    88   create_libtest_source "test.c" "$2"

    89   rm -f "$TEMP_DIR/checklib"

    90   $TOOLCHAIN_CC -o "$TEMP_DIR/checklib" $CFLAGS $LDFLAGS "-l$1" "$TEMP_DIR/test.c" 2> /dev/null

    91 }

    93 check_cpp_lib()

    94 {

    95   # $1: libname

    96   # $2: optional include

    97   if [ -z "$TOOLCHAIN_CXX" ]; then

    98     return 1

    99   fi

   100   create_libtest_source "test.cpp" "$2"

   101   rm -f "$TEMP_DIR/checklib"

   102   $TOOLCHAIN_CXX -o "$TEMP_DIR/checklib" $CXXFLAGS $LDFLAGS "-l$1" "$TEMP_DIR/test.cpp" 2> /dev/null

   103 }

   105 check_lib()

   106 {

   107   # $1: libname

   108   # $2: optional include

   109   if [ -n "$TOOLCHAIN_CC" ]; then

   110     check_c_lib "$1" "$2"

   111   elif  [ -n "$TOOLCHAIN_CXX" ]; then

   112     check_cpp_lib "$1" "$2"

   113   fi

   114 }

   116 detect_c_compiler()

   117 {

   118   if [ -n "$TOOLCHAIN_CC" ]; then

   119     return 0

   120   fi

   121   printf "detect C compiler... "

   122   if [ -n "$CC" ]; then

   123     if check_c_compiler "$CC"; then

   124       TOOLCHAIN_CC=$CC

   125       TOOLCHAIN=`"$TEMP_DIR/checkcc"`

   126       TOOLCHAIN_NAME=`echo "$TOOLCHAIN" | cut -f1 -d' ' -`

   127       echo "$CC"

   128       return 0

   129     else

   130       echo "$CC is not a working C compiler"

   131       return 1

   132     fi

   133   else

   134     for COMP in $C_COMPILERS

   135     do

   136       if check_c_compiler "$COMP"; then

   137         TOOLCHAIN_CC=$COMP

   138         TOOLCHAIN=`"$TEMP_DIR/checkcc"`

   139         TOOLCHAIN_NAME=`echo "$TOOLCHAIN" | cut -f1 -d' ' -`

   140         echo "$COMP"

   141         return 0

   142       fi

   143     done

   144     echo "not found"

   145     return 1

   146   fi

   147 }

   149 detect_cpp_compiler()

   150 {

   151   if [ -n "$TOOLCHAIN_CXX" ]; then

   152     return 0

   153   fi

   154   printf "detect C++ compiler... "

   156   if [ -n "$CXX" ]; then

   157     if check_cpp_compiler "$CXX"; then

   158       TOOLCHAIN_CXX=$CXX

   159       TOOLCHAIN=`"$TEMP_DIR/checkcc"`

   160       TOOLCHAIN_NAME=`echo "$TOOLCHAIN" | cut -f1 -d' ' -`

   161       echo "$CXX"

   162       return 0

   163     else

   164       echo "$CXX is not a working C++ compiler"

   165       return 1

   166     fi

   167   else

   168     for COMP in $CPP_COMPILERS

   169     do

   170       if check_cpp_compiler "$COMP"; then

   171         TOOLCHAIN_CXX=$COMP

   172         TOOLCHAIN=`"$TEMP_DIR/checkcc"`

   173         TOOLCHAIN_NAME=`echo "$TOOLCHAIN" | cut -f1 -d' ' -`

   174         echo "$COMP"

   175         return 0

   176       fi

   177     done

   178     echo "${TOOLCHAIN_CXX:-"not found"}"

   179     return 1

   180   fi

   181 }

   183 write_toolchain_defaults()

   184 {

   185   echo "# toolchain" >> "$1"

   186   if [ -n "$TOOLCHAIN_CC" ]; then

   187     echo "CC = ${TOOLCHAIN_CC}" >> "$1"

   188   fi

   189   if [ -n "$TOOLCHAIN_CXX" ]; then

   190     echo "CXX = ${TOOLCHAIN_CXX}" >> "$1"

   191   fi

   192   echo >> "$1"

   193   if [ -f "make/${TOOLCHAIN_NAME}.mk" ]; then

   194     cat "make/${TOOLCHAIN_NAME}.mk" >> "$1"

   195   elif [ -f "make/cc.mk" ]; then

   196     cat "make/cc.mk" >> "$1"

   197   else

   198     echo "!!! WARNING !!! Default toolchain flags not found. Configuration might be incomplete."

   199   fi

   200 }

Mercurial > hg > ucx / file revision