scripts/checks.sh

   1 #!/bin/sh
   2 #
   3 # Copyright 2005-2006 Timo Hirvonen
   4 #
   5 # This file is licensed under the GPLv2.
   6
   7 # C compiler
   8 # ----------
   9 # CC          default gcc
  10 # LD          default $CC
  11 # LDFLAGS     common linker flags for CC
  12 #
  13 # C++ Compiler
  14 # ------------
  15 # CXX         default g++
  16 # CXXLD       default $CXX
  17 # CXXLDFLAGS  common linker flags for CXX
  18 #
  19 # Common for C and C++
  20 # --------------------
  21 # SOFLAGS     flags for compiling position independent code (-fPIC)
  22 # LDSOFLAGS   flags for linking shared libraries
  23 # LDDLFLAGS   flags for linking dynamically loadable modules
  24
  25 msg_checking()
  26 {
  27         printf "checking $@... "
  28 }
  29
  30 msg_result()
  31 {
  32         echo "$@"
  33 }
  34
  35 msg_error()
  36 {
  37         echo "*** $@"
  38 }
  39
  40 # @program: program to check
  41 # @name:    name of variable where to store the full program name (optional)
  42 #
  43 # returns 0 on success and 1 on failure
  44 check_program()
  45 {
  46         argc check_program $# 1 2
  47         msg_checking "for program $1"
  48         __cp_file=`path_find "$1"`
  49         if test $? -eq 0
  50         then
  51                 msg_result $__cp_file
  52                 test $# -eq 2 && set_var $2 "$__cp_file"
  53                 return 0
  54         else
  55                 msg_result "no"
  56                 return 1
  57         fi
  58 }
  59
  60 cc_supports()
  61 {
  62         $CC $CFLAGS "$@" -S -o /dev/null -x c /dev/null 2> /dev/null
  63         return $?
  64 }
  65
  66 cxx_supports()
  67 {
  68         $CXX $CXXFLAGS "$@" -S -o /dev/null -x c /dev/null 2> /dev/null
  69         return $?
  70 }
  71
  72 # @flag: option flag(s) to check
  73 #
  74 # add @flag to EXTRA_CFLAGS if CC accepts it
  75 # EXTRA_CFLAGS are added to CFLAGS in the end of configuration
  76 check_cc_flag()
  77 {
  78         argc check_cc_flag $# 1
  79
  80         test -z "$CC" && die "check_cc_flag: CC not set"
  81         msg_checking "for CFLAGS $*"
  82         if cc_supports $*
  83         then
  84                 EXTRA_CFLAGS="$EXTRA_CFLAGS $*"
  85                 msg_result "yes"
  86                 return 0
  87         else
  88                 msg_result "no"
  89                 return 1
  90         fi
  91 }
  92
  93 # @flag: option flag(s) to check
  94 #
  95 # add @flag to EXTRA_CXXFLAGS if CXX accepts it
  96 # EXTRA_CXXFLAGS are added to CXXFLAGS in the end of configuration
  97 check_cxx_flag()
  98 {
  99         argc check_cxx_flag $# 1
 100
 101         test -z "$CXX" && die "check_cxx_flag: CXX not set"
 102         msg_checking "for CXXFLAGS $*"
 103         if cxx_supports $*
 104         then
 105                 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS $*"
 106                 msg_result "yes"
 107                 return 0
 108         else
 109                 msg_result "no"
 110                 return 1
 111         fi
 112 }
 113
 114 cc_cxx_common()
 115 {
 116         test "$cc_cxx_common_done" && return 0
 117         cc_cxx_common_done=yes
 118
 119         var_default SOFLAGS "-fPIC"
 120         var_default LDSOFLAGS "-shared"
 121         var_default LDDLFLAGS "-shared"
 122
 123         common_cf=
 124         common_lf=
 125
 126         case `uname -s` in
 127         *BSD)
 128                 common_cf="$common_cf -I/usr/local/include"
 129                 common_lf="$common_lf -L/usr/local/lib"
 130                 ;;
 131         Darwin)
 132                 # fink
 133                 if test -d /sw/lib
 134                 then
 135                         common_cf="$common_cf -I/sw/include"
 136                         common_lf="$common_lf -L/sw/lib"
 137                 fi
 138                 # darwinports
 139                 if test -d /opt/local/lib
 140                 then
 141                         common_cf="$common_cf -I/opt/local/include"
 142                         common_lf="$common_lf -L/opt/local/lib"
 143                 fi
 144                 LDSOFLAGS="-dynamic"
 145                 case ${MACOSX_DEPLOYMENT_TARGET} in
 146                 10.[012])
 147                         LDDLFLAGS="-bundle -flat_namespace -undefined suppress"
 148                         ;;
 149                 10.*)
 150                         LDDLFLAGS="-bundle -undefined dynamic_lookup"
 151                         ;;
 152                 *)
 153                         LDDLFLAGS="-bundle -flat_namespace -undefined suppress"
 154                         ;;
 155                 esac
 156                 ;;
 157         SunOS)
 158                 common_cf="$common_cf -D__EXTENSIONS__ -I/usr/local/include"
 159                 common_lf="$common_lf -R/usr/local/lib -L/usr/local/lib"
 160                 ;;
 161         esac
 162         makefile_vars SOFLAGS LDSOFLAGS LDDLFLAGS
 163 }
 164
 165 # CC, LD, CFLAGS, LDFLAGS, SOFLAGS, LDSOFLAGS, LDDLFLAGS
 166 check_cc()
 167 {
 168         var_default CC ${CROSS}gcc
 169         var_default LD $CC
 170         var_default CFLAGS "-g -O2 -Wall"
 171         var_default LDFLAGS ""
 172         check_program $CC || return 1
 173
 174         cc_cxx_common
 175         CFLAGS="$CFLAGS $common_cf"
 176         LDFLAGS="$LDFLAGS $common_lf"
 177
 178         makefile_vars CC LD CFLAGS LDFLAGS
 179         __check_lang=c
 180         return 0
 181 }
 182
 183 # CXX, CXXLD, CXXFLAGS, CXXLDFLAGS, SOFLAGS, LDSOFLAGS, LDDLFLAGS
 184 check_cxx()
 185 {
 186         var_default CXX ${CROSS}g++
 187         var_default CXXLD $CXX
 188         var_default CXXFLAGS "-g -O2 -Wall"
 189         var_default CXXLDFLAGS ""
 190         check_program $CXX || return 1
 191
 192         cc_cxx_common
 193         CXXFLAGS="$CXXFLAGS $common_cf"
 194         CXXLDFLAGS="$CXXLDFLAGS $common_lf"
 195
 196         makefile_vars CXX CXXLD CXXFLAGS CXXLDFLAGS
 197         __check_lang=cxx
 198         return 0
 199 }
 200
 201 # check if CC can generate dependencies (.dep-*.o files)
 202 # always succeeds
 203 check_cc_depgen()
 204 {
 205         msg_checking "if CC can generate dependency information"
 206         if cc_supports -MMD -MP -MF /dev/null
 207         then
 208                 EXTRA_CFLAGS="$EXTRA_CFLAGS -MMD -MP -MF .dep-\$(subst /,-,\$@)"
 209                 msg_result yes
 210         else
 211                 msg_result no
 212         fi
 213         return 0
 214 }
 215
 216 # check if CXX can generate dependencies (.dep-*.o files)
 217 # always succeeds
 218 check_cxx_depgen()
 219 {
 220         msg_checking "if CXX can generate dependency information"
 221         if cxx_supports -MMD -MP -MF /dev/null
 222         then
 223                 EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -MMD -MP -MF .dep-\$(subst /,-,\$@)"
 224                 msg_result yes
 225         else
 226                 msg_result no
 227         fi
 228         return 0
 229 }
 230
 231 # adds AR to config.mk
 232 check_ar()
 233 {
 234         var_default AR ${CROSS}ar
 235         var_default ARFLAGS "-cr"
 236         if check_program $AR
 237         then
 238                 makefile_vars AR ARFLAGS
 239                 return 0
 240         fi
 241         return 1
 242 }
 243
 244 # adds AS to config.mk
 245 check_as()
 246 {
 247         var_default AS ${CROSS}gcc
 248         if check_program $AS
 249         then
 250                 makefile_vars AS
 251                 return 0
 252         fi
 253         return 1
 254 }
 255
 256 check_pkgconfig()
 257 {
 258         if test -z "$PKG_CONFIG"
 259         then
 260                 if check_program pkg-config PKG_CONFIG
 261                 then
 262                         makefile_vars PKG_CONFIG
 263                 else
 264                         # don't check again
 265                         PKG_CONFIG="no"
 266                         return 1
 267                 fi
 268         fi
 269         return 0
 270 }
 271
 272 # check for library FOO and add FOO_CFLAGS and FOO_LIBS to config.mk
 273 #
 274 # @name:    variable prefix (e.g. CURSES -> CURSES_CFLAGS, CURSES_LIBS)
 275 # @cflags:  CFLAGS for the lib
 276 # @libs:    LIBS to check
 277 #
 278 # adds @name_CFLAGS and @name_LIBS to config.mk
 279 # CFLAGS are not checked, they are assumed to be correct
 280 check_library()
 281 {
 282         argc check_library $# 3 3
 283         msg_checking "for ${1}_LIBS ($3)"
 284         if try_link $3
 285         then
 286                 msg_result yes
 287                 makefile_var ${1}_CFLAGS "$2"
 288                 makefile_var ${1}_LIBS "$3"
 289                 return 0
 290         else
 291                 msg_result no
 292                 return 1
 293         fi
 294 }
 295
 296 # run pkg-config
 297 #
 298 # @prefix:  variable prefix (e.g. GLIB -> GLIB_CFLAGS, GLIB_LIBS)
 299 # @modules: the argument for pkg-config
 300 # @cflags:  CFLAGS to use if pkg-config failed (optional)
 301 # @libs:    LIBS to use if pkg-config failed (optional)
 302 #
 303 # if pkg-config fails and @libs are given check_library is called
 304 #
 305 # example:
 306 #   ---
 307 #   check_glib()
 308 #   {
 309 #           pkg_config GLIB "glib-2.0 >= 2.2"
 310 #           return $?
 311 #   }
 312 #
 313 #   check check_cc
 314 #   check check_glib
 315 #   ---
 316 #   GLIB_CFLAGS and GLIB_LIBS are automatically added to Makefile
 317 pkg_config()
 318 {
 319         argc pkg_config $# 2 4
 320
 321         # optional
 322         __pc_cflags="$3"
 323         __pc_libs="$4"
 324
 325         check_pkgconfig
 326         msg_checking "for ${1}_LIBS (pkg-config)"
 327         if test "$PKG_CONFIG" != "no" && $PKG_CONFIG --exists "$2" >/dev/null 2>&1
 328         then
 329                 # pkg-config is installed and the .pc file exists
 330                 __pc_libs="`$PKG_CONFIG --libs ""$2""`"
 331                 msg_result "$__pc_libs"
 332
 333                 msg_checking "for ${1}_CFLAGS (pkg-config)"
 334                 __pc_cflags="`$PKG_CONFIG --cflags ""$2""`"
 335                 msg_result "$__pc_cflags"
 336
 337                 makefile_var ${1}_CFLAGS "$__pc_cflags"
 338                 makefile_var ${1}_LIBS "$__pc_libs"
 339                 return 0
 340         fi
 341
 342         # no pkg-config or .pc file
 343         msg_result "no"
 344
 345         if test -z "$__pc_libs"
 346         then
 347                 if test "$PKG_CONFIG" = "no"
 348                 then
 349                         # pkg-config not installed and no libs to check were given
 350                         msg_error "pkg-config required for $1"
 351                 else
 352                         # pkg-config is installed but the required .pc file wasn't found
 353                         $PKG_CONFIG --errors-to-stdout --print-errors "$2" | sed 's:^:*** :'
 354                 fi
 355                 return 1
 356         fi
 357
 358         check_library "$1" "$__pc_cflags" "$__pc_libs"
 359         return $?
 360 }
 361
 362 # old name
 363 pkg_check_modules()
 364 {
 365         pkg_config "$@"
 366 }
 367
 368 # run *-config
 369 #
 370 # @prefix:  variable prefix (e.g. ARTS -> ARTS_CFLAGS, ARTS_LIBS)
 371 # @program: the -config program
 372 #
 373 # example:
 374 #   ---
 375 #   check_arts()
 376 #   {
 377 #           app_config ARTS artsc-config
 378 #           return $?
 379 #   }
 380 #
 381 #   check check_cc
 382 #   check check_arts
 383 #   ---
 384 #   ARTS_CFLAGS and ARTS_LIBS are automatically added to config.mk
 385 app_config()
 386 {
 387         argc app_config $# 2 2
 388         check_program $2 || return 1
 389
 390         msg_checking "for ${1}_CFLAGS"
 391         __ac_cflags="`$2 --cflags`"
 392         msg_result "$__ac_cflags"
 393
 394         msg_checking "for ${1}_LIBS"
 395         __ac_libs="`$2 --libs`"
 396         msg_result "$__ac_libs"
 397
 398         makefile_var ${1}_CFLAGS "$__ac_cflags"
 399         makefile_var ${1}_LIBS "$__ac_libs"
 400         return 0
 401 }
 402
 403 # @contents:  file contents to compile
 404 # @cflags:    extra cflags (optional)
 405 try_compile()
 406 {
 407         argc try_compile $# 1
 408         case $__check_lang in
 409         c)
 410                 __src=`tmp_file prog.c`
 411                 __obj=`tmp_file prog.o`
 412                 echo "$1" > $__src || exit 1
 413                 shift
 414                 __cmd="$CC -c $CFLAGS $@ $__src -o $__obj"
 415                 $CC -c $CFLAGS "$@" $__src -o $__obj 2>/dev/null
 416                 ;;
 417         cxx)
 418                 __src=`tmp_file prog.cc`
 419                 __obj=`tmp_file prog.o`
 420                 echo "$1" > $__src || exit 1
 421                 shift
 422                 __cmd="$CXX -c $CXXFLAGS $@ $__src -o $__obj"
 423                 $CXX -c $CXXFLAGS "$@" $__src -o $__obj 2>/dev/null
 424                 ;;
 425         esac
 426         return $?
 427 }
 428
 429 # @contents:  file contents to compile and link
 430 # @flags:     extra flags (optional)
 431 try_compile_link()
 432 {
 433         argc try_compile $# 1
 434         case $__check_lang in
 435         c)
 436                 __src=`tmp_file prog.c`
 437                 __exe=`tmp_file prog`
 438                 echo "$1" > $__src || exit 1
 439                 shift
 440                 __cmd="$CC $CFLAGS $LDFLAGS $@ $__src -o $__exe"
 441                 $CC $CFLAGS $LDFLAGS "$@" $__src -o $__exe 2>/dev/null
 442                 ;;
 443         cxx)
 444                 __src=`tmp_file prog.cc`
 445                 __exe=`tmp_file prog`
 446                 echo "$1" > $__src || exit 1
 447                 shift
 448                 __cmd="$CXX $CXXFLAGS $CXXLDFLAGS $@ $__src -o $__exe"
 449                 $CXX $CXXFLAGS $CXXLDFLAGS "$@" $__src -o $__exe 2>/dev/null
 450                 ;;
 451         esac
 452         return $?
 453 }
 454
 455 # optionally used after try_compile or try_compile_link
 456 __compile_failed()
 457 {
 458         warn
 459         warn "Failed to compile simple program:"
 460         warn "---"
 461         cat $__src >&2
 462         warn "---"
 463         warn "Command: $__cmd"
 464         case $__check_lang in
 465         c)
 466                 warn "Make sure your CC and CFLAGS are sane."
 467                 ;;
 468         cxx)
 469                 warn "Make sure your CXX and CXXFLAGS are sane."
 470                 ;;
 471         esac
 472         exit 1
 473 }
 474
 475 # tries to link against a lib
 476 #
 477 # @ldadd:  something like -L/usr/X11R6/lib -lX11
 478 try_link()
 479 {
 480         try_compile_link "int main(int argc, char *argv[]) { return 0; }" "$@"
 481         return $?
 482 }
 483
 484 # compile and run
 485 #
 486 # @code:  simple program code to run
 487 run_code()
 488 {
 489         try_compile_link "$1" || __compile_failed
 490         ./$__exe
 491         return $?
 492 }
 493
 494 # check if the architecture is big-endian
 495 #
 496 # defines WORDS_BIGENDIAN=y/n
 497 check_endianness()
 498 {
 499         msg_checking "byte order"
 500         if run_code "
 501 int main(int argc, char *argv[])
 502 {
 503         unsigned int i = 1;
 504         return *(char *)&i;
 505 }"
 506         then
 507                 msg_result "big-endian"
 508                 WORDS_BIGENDIAN=y
 509         else
 510                 msg_result "little-endian"
 511                 WORDS_BIGENDIAN=n
 512         fi
 513         return 0
 514 }
 515
 516 # check if @header can be included
 517 #
 518 # @header
 519 # @cflags   -I/some/path (optional)
 520 check_header()
 521 {
 522         argc check_header $# 1
 523         __header="$1"
 524         shift
 525         msg_checking "for header <$__header>"
 526         if try_compile "#include <$__header>" "$@"
 527         then
 528                 msg_result yes
 529                 return 0
 530         fi
 531         msg_result no
 532         return 1
 533 }
 534
 535 # check X11 libs
 536 #
 537 # adds X11_LIBS (and empty X11_CFLAGS) to config.mk
 538 check_x11()
 539 {
 540         for __libs in "-lX11" "-L/usr/X11R6/lib -lX11"
 541         do
 542                 check_library X11 "" "$__libs" && return 0
 543         done
 544         return 1
 545 }
 546
 547 # check posix threads
 548 #
 549 # adds PTHREAD_CFLAGS and PTHREAD_LIBS to config.mk
 550 check_pthread()
 551 {
 552         for __libs in "$PTHREAD_LIBS" -lpthread -lc_r -lkse
 553         do
 554                 test -z "$__libs" && continue
 555                 check_library PTHREAD "-D_REENTRANT" "$__libs" && return 0
 556         done
 557         echo "using -pthread gcc option"
 558         makefile_var PTHREAD_CFLAGS "-pthread -D_THREAD_SAFE"
 559         makefile_var PTHREAD_LIBS "-pthread"
 560         return 0
 561 }
 562
 563 # check dynamic linking loader
 564 #
 565 # adds DL_LIBS to config.mk
 566 check_dl()
 567 {
 568         for DL_LIBS in "-ldl -Wl,--export-dynamic" "-Wl,--export-dynamic" "-ldl"
 569         do
 570                 check_library DL "" "$DL_LIBS" && return 0
 571         done
 572         echo "assuming -ldl is not needed"
 573         DL_LIBS=
 574         makefile_vars DL_LIBS DL_CFLAGS
 575         return 0
 576 }
 577
 578 # check for iconv
 579 #
 580 # adds ICONV_CFLAGS and ICONV_LIBS to config.mk
 581 check_iconv()
 582 {
 583         check_library ICONV "" "-liconv" && return 0
 584
 585         echo "assuming libc contains iconv"
 586         makefile_var ICONV_CFLAGS ""
 587         makefile_var ICONV_LIBS ""
 588         return 0
 589 }