builds/unix/configure.raw

   1 # This file is part of the FreeType project.
   2 #
   3 # Process this file with autoconf to produce a configure script.
   4 #
   5 # Copyright 2001-2012 by
   6 # David Turner, Robert Wilhelm, and Werner Lemberg.
   7 #
   8 # This file is part of the FreeType project, and may only be used, modified,
   9 # and distributed under the terms of the FreeType project license,
  10 # LICENSE.TXT.  By continuing to use, modify, or distribute this file you
  11 # indicate that you have read the license and understand and accept it
  12 # fully.
  13
  14 AC_INIT([FreeType], [@VERSION@], [freetype@nongnu.org], [freetype])
  15 AC_CONFIG_SRCDIR([ftconfig.in])
  16
  17
  18 # Don't forget to update docs/VERSION.DLL!
  19
  20 version_info='14:1:8'
  21 AC_SUBST([version_info])
  22 ft_version=`echo $version_info | tr : .`
  23 AC_SUBST([ft_version])
  24
  25
  26 # checks for system type
  27
  28 AC_CANONICAL_HOST
  29
  30
  31 # checks for programs
  32
  33 AC_PROG_CC
  34 AC_PROG_CPP
  35 AC_SUBST(EXEEXT)
  36
  37
  38 # checks for native programs to generate building tool
  39
  40 if test ${cross_compiling} = yes; then
  41   AC_CHECK_PROG(CC_BUILD, ${build}-gcc, ${build}-gcc)
  42   test -z "${CC_BUILD}" && AC_CHECK_PROG(CC_BUILD, gcc, gcc)
  43   test -z "${CC_BUILD}" && AC_CHECK_PROG(CC_BUILD, cc, cc, , , /usr/ucb/cc)
  44   test -z "${CC_BUILD}" && AC_MSG_ERROR([cannot find native C compiler])
  45
  46   AC_MSG_CHECKING([for suffix of native executables])
  47   rm -f a.* b.* a_out.exe conftest.*
  48   echo > conftest.c "int main() { return 0;}"
  49   ${CC_BUILD} conftest.c || AC_MSG_ERROR([native C compiler is not working])
  50   rm -f conftest.c
  51   if test -x a.out -o -x b.out -o -x conftest; then
  52     EXEEXT_BUILD=""
  53   elif test -x a_out.exe -o -x conftest.exe; then
  54     EXEEXT_BUILD=".exe"
  55   elif test -x conftest.*; then
  56     EXEEXT_BUILD=`echo conftest.* | sed -n '1s/^.*\././'`
  57   fi
  58   rm -f a.* b.* a_out.exe conftest.*
  59   AC_MSG_RESULT($EXEEXT_BUILD)
  60 else
  61   CC_BUILD=${CC}
  62   EXEEXT_BUILD=${EXEEXT}
  63 fi
  64
  65 AC_SUBST(CC_BUILD)
  66 AC_SUBST(EXEEXT_BUILD)
  67
  68
  69
  70 # get compiler flags right
  71
  72 if test "x$GCC" = xyes; then
  73   XX_CFLAGS="-Wall"
  74   XX_ANSIFLAGS="-pedantic -ansi"
  75 else
  76   case "$host" in
  77   *-dec-osf*)
  78     CFLAGS=
  79     XX_CFLAGS="-std1 -g3"
  80     XX_ANSIFLAGS=
  81     ;;
  82   *)
  83     XX_CFLAGS=
  84     XX_ANSIFLAGS=
  85     ;;
  86   esac
  87 fi
  88 AC_SUBST([XX_CFLAGS])
  89 AC_SUBST([XX_ANSIFLAGS])
  90
  91
  92 # auxiliary programs
  93
  94 AC_CHECK_PROG([RMF], [rm], [rm -f])
  95 AC_CHECK_PROG([RMDIR], [rmdir], [rmdir])
  96
  97
  98 # Since this file will be finally moved to another directory we make
  99 # the path of the install script absolute.  This small code snippet has
 100 # been taken from automake's `ylwrap' script.
 101
 102 AC_PROG_INSTALL
 103 case "$INSTALL" in
 104 /*)
 105   ;;
 106 */*)
 107   INSTALL="`pwd`/$INSTALL"
 108   ;;
 109 esac
 110
 111
 112 # checks for header files
 113
 114 AC_HEADER_STDC
 115 AC_CHECK_HEADERS([fcntl.h unistd.h])
 116
 117
 118 # checks for typedefs, structures, and compiler characteristics
 119
 120 AC_C_CONST
 121 AC_CHECK_SIZEOF([int])
 122 AC_CHECK_SIZEOF([long])
 123
 124
 125 # check whether cpp computation of size of int and long in ftconfig.in works
 126
 127 AC_MSG_CHECKING([whether cpp computation of bit length in ftconfig.in works])
 128 orig_CPPFLAGS="${CPPFLAGS}"
 129 CPPFLAGS="-I${srcdir} -I. ${CPPFLAGS}"
 130 ac_clean_files="ft2build.h ftoption.h ftstdlib.h"
 131 touch ft2build.h ftoption.h ftstdlib.h
 132
 133 cat > conftest.c <<\_ACEOF
 134 #include <limits.h>
 135 #define FT_CONFIG_OPTIONS_H "ftoption.h"
 136 #define FT_CONFIG_STANDARD_LIBRARY_H "ftstdlib.h"
 137 #define FT_UINT_MAX  UINT_MAX
 138 #define FT_ULONG_MAX ULONG_MAX
 139 #include "ftconfig.in"
 140 _ACEOF
 141 echo >> conftest.c "#if FT_SIZEOF_INT == "${ac_cv_sizeof_int}
 142 echo >> conftest.c "ac_cpp_ft_sizeof_int="${ac_cv_sizeof_int}
 143 echo >> conftest.c "#endif"
 144 echo >> conftest.c "#if FT_SIZEOF_LONG == "${ac_cv_sizeof_long}
 145 echo >> conftest.c "ac_cpp_ft_sizeof_long="${ac_cv_sizeof_long}
 146 echo >> conftest.c "#endif"
 147
 148 ${CPP} ${CPPFLAGS} conftest.c | ${GREP} ac_cpp_ft > conftest.sh
 149 eval `cat conftest.sh`
 150 ${RMF} conftest.c conftest.sh confft2build.h ftoption.h ftstdlib.h
 151
 152 if test x != "x${ac_cpp_ft_sizeof_int}" \
 153    -a x != x"${ac_cpp_ft_sizeof_long}"; then
 154   unset ft_use_autoconf_sizeof_types
 155 else
 156   ft_use_autoconf_sizeof_types=yes
 157 fi
 158
 159 AC_ARG_ENABLE(biarch-config,
 160 [  --enable-biarch-config  install biarch ftconfig.h to support multiple
 161                           architectures by single file], [], [])
 162
 163 case :${ft_use_autoconf_sizeof_types}:${enable_biarch_config}: in
 164   :yes:yes:)
 165     AC_MSG_RESULT([broken but use it])
 166     unset ft_use_autoconf_sizeof_types
 167     ;;
 168   ::no:)
 169     AC_MSG_RESULT([works but ignore it])
 170     ft_use_autoconf_sizeof_types=yes
 171     ;;
 172   ::yes: | :::)
 173     AC_MSG_RESULT([yes])
 174     unset ft_use_autoconf_sizeof_types
 175     ;;
 176   *)
 177     AC_MSG_RESULT([no])
 178     ft_use_autoconf_sizeof_types=yes
 179     ;;
 180 esac
 181
 182 if test x"${ft_use_autoconf_sizeof_types}" = xyes; then
 183   AC_DEFINE([FT_USE_AUTOCONF_SIZEOF_TYPES])
 184 fi
 185
 186 CPPFLAGS="${orig_CPPFLAGS}"
 187
 188
 189 # checks for library functions
 190
 191 # Here we check whether we can use our mmap file component.
 192
 193 AC_ARG_ENABLE([mmap],
 194   AS_HELP_STRING([--disable-mmap],
 195                  [do not check mmap() and do not use]),
 196   [enable_mmap="no"],[enable_mmap="yes"])
 197 if test "x${enable_mmap}" != "xno"; then
 198   AC_FUNC_MMAP
 199 fi
 200 if test "x${enable_mmap}" = "xno" \
 201    -o "$ac_cv_func_mmap_fixed_mapped" != "yes"; then
 202   FTSYS_SRC='$(BASE_DIR)/ftsystem.c'
 203 else
 204   FTSYS_SRC='$(BUILD_DIR)/ftsystem.c'
 205
 206   AC_CHECK_DECLS([munmap],
 207     [],
 208     [],
 209     [
 210
 211 #ifdef HAVE_UNISTD_H
 212 #include <unistd.h>
 213 #endif
 214 #include <sys/mman.h>
 215
 216     ])
 217
 218   FT_MUNMAP_PARAM
 219 fi
 220 AC_SUBST([FTSYS_SRC])
 221
 222 AC_CHECK_FUNCS([memcpy memmove])
 223
 224
 225 # check for system zlib
 226
 227 # don't quote AS_HELP_STRING!
 228 AC_ARG_WITH([zlib],
 229   AS_HELP_STRING([--without-zlib],
 230                  [use internal zlib instead of system-wide]))
 231 if test x$with_zlib != xno && test -z "$LIBZ"; then
 232   AC_CHECK_LIB([z], [gzsetparams], [AC_CHECK_HEADER([zlib.h], [LIBZ='-lz'])])
 233 fi
 234 if test x$with_zlib != xno && test -n "$LIBZ"; then
 235   CFLAGS="$CFLAGS -DFT_CONFIG_OPTION_SYSTEM_ZLIB"
 236   LDFLAGS="$LDFLAGS $LIBZ"
 237   SYSTEM_ZLIB=yes
 238 fi
 239
 240 # check for system libbz2
 241
 242 # don't quote AS_HELP_STRING!
 243 AC_ARG_WITH([bzip2],
 244   AS_HELP_STRING([--without-bzip2],
 245                  [do not support bzip2 compressed fonts]))
 246 if test x$with_bzip2 != xno && test -z "$LIBBZ2"; then
 247   AC_CHECK_LIB([bz2], [BZ2_bzDecompress], [AC_CHECK_HEADER([bzlib.h], [LIBBZ2='-lbz2'])])
 248 fi
 249 if test x$with_bzip2 != xno && test -n "$LIBBZ2"; then
 250   CFLAGS="$CFLAGS -DFT_CONFIG_OPTION_USE_BZIP2"
 251   LDFLAGS="$LDFLAGS $LIBBZ2"
 252 fi
 253
 254 # Some options handling SDKs/archs in CFLAGS should be copied
 255 # to LDFLAGS. Apple TechNote 2137 recommends to include these
 256 # options in CFLAGS but not in LDFLAGS.
 257
 258 save_config_args=$*
 259 set dummy ${CFLAGS}
 260 i=1
 261 while test $i -le $#
 262 do
 263   c=$1
 264
 265   case "${c}" in
 266   -isysroot|-arch) # options taking 1 argument
 267     a=$2
 268     AC_MSG_CHECKING([whether CFLAGS and LDFLAGS share ${c} ${a}])
 269     if expr " ${LDFLAGS} " : ".* ${c} *${a}.*" > /dev/null
 270     then
 271       AC_MSG_RESULT([yes])
 272     else
 273       AC_MSG_RESULT([no, copy to LDFLAGS])
 274       LDFLAGS="${LDFLAGS} ${c} ${a}"
 275     fi
 276     shift 1
 277     ;;
 278   -m32|-m64|-march=*|-mcpu=*) # options taking no argument
 279     AC_MSG_RESULT([whether CFLAGS and LDFLAGS share ${c}])
 280     if expr " ${LDFLAGS} " : ".* ${c} *${a}.*" > /dev/null
 281     then
 282       AC_MSG_RESULT([yes])
 283     else
 284       AC_MSG_RESULT([no, copy to LDFLAGS])
 285       LDFLAGS="${LDFLAGS} ${c}"
 286     fi
 287     ;;
 288   # *)
 289   #   AC_MSG_RESULT([${c} is not copied to LDFLAGS])
 290   #   ;;
 291   esac
 292
 293   shift 1
 294 done
 295 set ${save_config_args}
 296
 297
 298 # Whether to use Mac OS resource-based fonts.
 299
 300 ftmac_c="" # src/base/ftmac.c should not be included in makefiles by default
 301
 302 # don't quote AS_HELP_STRING!
 303 AC_ARG_WITH([old-mac-fonts],
 304   AS_HELP_STRING([--with-old-mac-fonts],
 305                  [allow Mac resource-based fonts to be used]))
 306 if test x$with_old_mac_fonts = xyes; then
 307   orig_LDFLAGS="${LDFLAGS}"
 308   AC_MSG_CHECKING([CoreServices & ApplicationServices of Mac OS X])
 309   FT2_EXTRA_LIBS="-Wl,-framework,CoreServices -Wl,-framework,ApplicationServices"
 310   LDFLAGS="$LDFLAGS $FT2_EXTRA_LIBS"
 311   AC_LINK_IFELSE([
 312     AC_LANG_PROGRAM([
 313
 314 #if defined(__GNUC__) && defined(__APPLE_CC__)
 315 # include <CoreServices/CoreServices.h>
 316 # include <ApplicationServices/ApplicationServices.h>
 317 #else
 318 # include <ConditionalMacros.h>
 319 # include <Files.h>
 320 #endif
 321
 322       ],
 323       [
 324
 325         short res = 0;
 326
 327
 328         UseResFile( res );
 329
 330       ])],
 331     [AC_MSG_RESULT([ok])
 332      ftmac_c='ftmac.c'
 333      AC_MSG_CHECKING([whether OS_INLINE macro is ANSI compatible])
 334      orig_CFLAGS="$CFLAGS -DFT_MACINTOSH"
 335      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 336      AC_COMPILE_IFELSE([
 337        AC_LANG_PROGRAM([
 338
 339 #if defined(__GNUC__) && defined(__APPLE_CC__)
 340 # include <CoreServices/CoreServices.h>
 341 # include <ApplicationServices/ApplicationServices.h>
 342 #else
 343 # include <ConditionalMacros.h>
 344 # include <Files.h>
 345 #endif
 346
 347          ],
 348          [
 349
 350            /* OSHostByteOrder() is typed as OS_INLINE */
 351            int32_t  os_byte_order = OSHostByteOrder();
 352
 353
 354            if ( OSBigEndian != os_byte_order )
 355              return 1;
 356
 357          ])],
 358        [AC_MSG_RESULT([ok])
 359         CFLAGS="$orig_CFLAGS"
 360         CFLAGS="$CFLAGS -DHAVE_ANSI_OS_INLINE=1"
 361        ],
 362        [AC_MSG_RESULT([no, ANSI incompatible])
 363         CFLAGS="$orig_CFLAGS"
 364        ])
 365      AC_MSG_CHECKING([type ResourceIndex])
 366      orig_CFLAGS="$CFLAGS"
 367      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 368      AC_COMPILE_IFELSE([
 369        AC_LANG_PROGRAM([
 370
 371 #if defined(__GNUC__) && defined(__APPLE_CC__)
 372 # include <CoreServices/CoreServices.h>
 373 # include <ApplicationServices/ApplicationServices.h>
 374 #else
 375 # include <ConditionalMacros.h>
 376 # include <Files.h>
 377 # include <Resources.h>
 378 #endif
 379
 380          ],
 381          [
 382
 383            ResourceIndex i = 0;
 384            return i;
 385
 386          ])],
 387        [AC_MSG_RESULT([ok])
 388         CFLAGS="$orig_CFLAGS"
 389         CFLAGS="$CFLAGS -DHAVE_TYPE_RESOURCE_INDEX=1"
 390        ],
 391        [AC_MSG_RESULT([no])
 392         CFLAGS="$orig_CFLAGS"
 393         CFLAGS="$CFLAGS -DHAVE_TYPE_RESOURCE_INDEX=0"
 394        ])],
 395     [AC_MSG_RESULT([not found])
 396      FT2_EXTRA_LIBS=""
 397      LDFLAGS="${orig_LDFLAGS}"
 398      CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"])
 399 else
 400   case x$host_os in
 401   xdarwin*)
 402     dnl AC_MSG_WARN([host system is MacOS but configured to build without Carbon])
 403     CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"
 404     ;;
 405   *)
 406     ;;
 407   esac
 408 fi
 409
 410
 411 # Whether to use FileManager which is deprecated since Mac OS X 10.4.
 412
 413 AC_ARG_WITH([fsspec],
 414   AS_HELP_STRING([--with-fsspec],
 415                  [use obsolete FSSpec API of MacOS, if available (default=yes)]))
 416 if test x$with_fsspec = xno; then
 417   CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"
 418 elif test x$with_old_mac_fonts = xyes -a x$with_fsspec != x; then
 419   AC_MSG_CHECKING([FSSpec-based FileManager])
 420   AC_LINK_IFELSE([
 421     AC_LANG_PROGRAM([
 422
 423 #if defined(__GNUC__) && defined(__APPLE_CC__)
 424 # include <CoreServices/CoreServices.h>
 425 # include <ApplicationServices/ApplicationServices.h>
 426 #else
 427 # include <ConditionalMacros.h>
 428 # include <Files.h>
 429 #endif
 430
 431       ],
 432       [
 433
 434         FCBPBPtr          paramBlock;
 435         short             vRefNum;
 436         long              dirID;
 437         ConstStr255Param  fileName;
 438         FSSpec*           spec;
 439
 440
 441         /* FSSpec functions: deprecated since Mac OS X 10.4 */
 442         PBGetFCBInfoSync( paramBlock );
 443         FSMakeFSSpec( vRefNum, dirID, fileName, spec );
 444
 445       ])],
 446     [AC_MSG_RESULT([ok])
 447      CFLAGS="$CFLAGS -DHAVE_FSSPEC=1"],
 448     [AC_MSG_RESULT([not found])
 449      CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"])
 450 fi
 451
 452
 453 # Whether to use FileManager in Carbon since MacOS 9.x.
 454
 455 AC_ARG_WITH([fsref],
 456   AS_HELP_STRING([--with-fsref],
 457                  [use Carbon FSRef API of MacOS, if available (default=yes)]))
 458 if test x$with_fsref = xno; then
 459   AC_MSG_WARN([
 460 *** WARNING
 461     FreeType2 built without FSRef API cannot load
 462     data-fork fonts on MacOS, except of XXX.dfont.
 463     ])
 464   CFLAGS="$CFLAGS -DHAVE_FSREF=0"
 465 elif test x$with_old_mac_fonts = xyes -a x$with_fsref != x; then
 466   AC_MSG_CHECKING([FSRef-based FileManager])
 467   AC_LINK_IFELSE([
 468     AC_LANG_PROGRAM([
 469
 470 #if defined(__GNUC__) && defined(__APPLE_CC__)
 471 # include <CoreServices/CoreServices.h>
 472 # include <ApplicationServices/ApplicationServices.h>
 473 #else
 474 # include <ConditionalMacros.h>
 475 # include <Files.h>
 476 #endif
 477
 478       ],
 479       [
 480
 481         short                vRefNum;
 482         long                 dirID;
 483         ConstStr255Param     fileName;
 484
 485         Boolean*             isDirectory;
 486         UInt8*               path;
 487         SInt16               desiredRefNum;
 488         SInt16*              iterator;
 489         SInt16*              actualRefNum;
 490         HFSUniStr255*        outForkName;
 491         FSVolumeRefNum       volume;
 492         FSCatalogInfoBitmap  whichInfo;
 493         FSCatalogInfo*       catalogInfo;
 494         FSForkInfo*          forkInfo;
 495         FSRef*               ref;
 496
 497 #if HAVE_FSSPEC
 498         FSSpec*              spec;
 499 #endif
 500
 501         /* FSRef functions: no need to check? */
 502         FSGetForkCBInfo( desiredRefNum, volume, iterator,
 503                          actualRefNum, forkInfo, ref,
 504                          outForkName );
 505         FSPathMakeRef( path, ref, isDirectory );
 506
 507 #if HAVE_FSSPEC
 508         FSpMakeFSRef ( spec, ref );
 509         FSGetCatalogInfo( ref, whichInfo, catalogInfo,
 510                           outForkName, spec, ref );
 511 #endif
 512       ])],
 513     [AC_MSG_RESULT([ok])
 514      CFLAGS="$CFLAGS -DHAVE_FSREF=1"],
 515     [AC_MSG_RESULT([not found])
 516      CFLAGS="$CFLAGS -DHAVE_FSREF=0"])
 517 fi
 518
 519
 520 # Whether to use QuickDraw API in ToolBox which is deprecated since
 521 # Mac OS X 10.4.
 522
 523 AC_ARG_WITH([quickdraw-toolbox],
 524   AS_HELP_STRING([--with-quickdraw-toolbox],
 525                  [use MacOS QuickDraw in ToolBox, if available (default=yes)]))
 526 if test x$with_quickdraw_toolbox = xno; then
 527   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"
 528 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_toolbox != x; then
 529   AC_MSG_CHECKING([QuickDraw FontManager functions in ToolBox])
 530   AC_LINK_IFELSE([
 531     AC_LANG_PROGRAM([
 532
 533 #if defined(__GNUC__) && defined(__APPLE_CC__)
 534 # include <CoreServices/CoreServices.h>
 535 # include <ApplicationServices/ApplicationServices.h>
 536 #else
 537 # include <ConditionalMacros.h>
 538 # include <Fonts.h>
 539 #endif
 540
 541       ],
 542       [
 543
 544         Str255     familyName;
 545         SInt16     familyID   = 0;
 546         FMInput*   fmIn       = NULL;
 547         FMOutput*  fmOut      = NULL;
 548
 549
 550         GetFontName( familyID, familyName );
 551         GetFNum( familyName, &familyID );
 552         fmOut = FMSwapFont( fmIn );
 553
 554       ])],
 555     [AC_MSG_RESULT([ok])
 556      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=1"],
 557     [AC_MSG_RESULT([not found])
 558      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"])
 559 fi
 560
 561
 562 # Whether to use QuickDraw API in Carbon which is deprecated since
 563 # Mac OS X 10.4.
 564
 565 AC_ARG_WITH([quickdraw-carbon],
 566   AS_HELP_STRING([--with-quickdraw-carbon],
 567                  [use MacOS QuickDraw in Carbon, if available (default=yes)]))
 568 if test x$with_quickdraw_carbon = xno; then
 569   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"
 570 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_carbon != x; then
 571   AC_MSG_CHECKING([QuickDraw FontManager functions in Carbon])
 572   AC_LINK_IFELSE([
 573     AC_LANG_PROGRAM([
 574
 575 #if defined(__GNUC__) && defined(__APPLE_CC__)
 576 # include <CoreServices/CoreServices.h>
 577 # include <ApplicationServices/ApplicationServices.h>
 578 #else
 579 # include <ConditionalMacros.h>
 580 # include <Fonts.h>
 581 #endif
 582
 583       ],
 584       [
 585
 586         FMFontFamilyIterator          famIter;
 587         FMFontFamily                  family;
 588         Str255                        famNameStr;
 589         FMFontFamilyInstanceIterator  instIter;
 590         FMFontStyle                   style;
 591         FMFontSize                    size;
 592         FMFont                        font;
 593         FSSpec*                       pathSpec;
 594
 595
 596         FMCreateFontFamilyIterator( NULL, NULL, kFMUseGlobalScopeOption,
 597                                     &famIter );
 598         FMGetNextFontFamily( &famIter, &family );
 599         FMGetFontFamilyName( family, famNameStr );
 600         FMCreateFontFamilyInstanceIterator( family, &instIter );
 601         FMGetNextFontFamilyInstance( &instIter, &font, &style, &size );
 602         FMDisposeFontFamilyInstanceIterator( &instIter );
 603         FMDisposeFontFamilyIterator( &famIter );
 604         FMGetFontContainer( font, pathSpec );
 605
 606       ])],
 607     [AC_MSG_RESULT([ok])
 608      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=1"],
 609     [AC_MSG_RESULT([not found])
 610      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"])
 611 fi
 612
 613
 614 # Whether to use AppleTypeService since Mac OS X.
 615
 616 # don't quote AS_HELP_STRING!
 617 AC_ARG_WITH([ats],
 618   AS_HELP_STRING([--with-ats],
 619                  [use AppleTypeService, if available (default=yes)]))
 620 if test x$with_ats = xno; then
 621   CFLAGS="$CFLAGS -DHAVE_ATS=0"
 622 elif test x$with_old_mac_fonts = xyes -a x$with_ats != x; then
 623   AC_MSG_CHECKING([AppleTypeService functions])
 624   AC_LINK_IFELSE([
 625     AC_LANG_PROGRAM([
 626
 627 #if defined(__GNUC__) && defined(__APPLE_CC__)
 628 # include <CoreServices/CoreServices.h>
 629 # include <ApplicationServices/ApplicationServices.h>
 630 #else
 631 # include <ConditionalMacros.h>
 632 # include <Files.h>
 633 #endif
 634
 635       ],
 636       [
 637
 638         FSSpec*  pathSpec;
 639
 640
 641         ATSFontFindFromName( NULL, kATSOptionFlagsUnRestrictedScope );
 642 #if HAVE_FSSPEC
 643         ATSFontGetFileSpecification( 0, pathSpec );
 644 #endif
 645
 646       ])],
 647     [AC_MSG_RESULT([ok])
 648      CFLAGS="$CFLAGS -DHAVE_ATS=1"],
 649     [AC_MSG_RESULT([not found])
 650      CFLAGS="$CFLAGS -DHAVE_ATS=0"])
 651 fi
 652
 653 case "$CFLAGS" in
 654   *HAVE_FSSPEC* | *HAVE_FSREF* | *HAVE_QUICKDRAW* | *HAVE_ATS* )
 655     AC_MSG_WARN([
 656 *** WARNING
 657     FSSpec/FSRef/QuickDraw/ATS options are explicitly given,
 658     thus it is recommended to replace src/base/ftmac.c by builds/mac/ftmac.c.
 659     ])
 660     CFLAGS="$CFLAGS "'-I$(TOP_DIR)/builds/mac/'
 661     ;;
 662   *)
 663     ;;
 664 esac
 665
 666
 667 AC_SUBST([ftmac_c])
 668 AC_SUBST([LIBZ])
 669 AC_SUBST([LIBBZ2])
 670 AC_SUBST([CFLAGS])
 671 AC_SUBST([LDFLAGS])
 672 AC_SUBST([FT2_EXTRA_LIBS])
 673 AC_SUBST([SYSTEM_ZLIB])
 674
 675
 676 LT_INIT(win32-dll)
 677
 678 AC_SUBST([hardcode_libdir_flag_spec])
 679 AC_SUBST([wl])
 680 AC_SUBST([build_libtool_libs])
 681
 682
 683 # configuration file -- stay in 8.3 limit
 684 #
 685 # since #undef doesn't survive in configuration header files we replace
 686 # `/undef' with `#undef' after creating the output file
 687
 688 AC_CONFIG_HEADERS([ftconfig.h:ftconfig.in],
 689   [mv ftconfig.h ftconfig.tmp
 690    sed 's|/undef|#undef|' < ftconfig.tmp > ftconfig.h
 691    rm ftconfig.tmp])
 692
 693 # create the Unix-specific sub-Makefiles `builds/unix/unix-def.mk'
 694 # and `builds/unix/unix-cc.mk' that will be used by the build system
 695 #
 696 AC_CONFIG_FILES([unix-cc.mk:unix-cc.in
 697                  unix-def.mk:unix-def.in
 698                  freetype-config
 699                  freetype2.pc:freetype2.in])
 700
 701 # re-generate the Jamfile to use libtool now
 702 #
 703 # AC_CONFIG_FILES([../../Jamfile:../../Jamfile.in])
 704
 705 AC_OUTPUT
 706
 707 # end of configure.raw