builds/unix/configure.ac

   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, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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], [2.4.3], [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='12:1:6'
  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 esac
 109
 110
 111 # checks for header files
 112
 113 AC_HEADER_STDC
 114 AC_CHECK_HEADERS([fcntl.h unistd.h])
 115
 116
 117 # checks for typedefs, structures, and compiler characteristics
 118
 119 AC_C_CONST
 120 AC_CHECK_SIZEOF([int])
 121 AC_CHECK_SIZEOF([long])
 122
 123
 124 # check whether cpp computation of size of int and long in ftconfig.in works
 125
 126 AC_MSG_CHECKING([cpp computation of bit length in ftconfig.in works])
 127 orig_CPPFLAGS="${CPPFLAGS}"
 128 CPPFLAGS="-I${srcdir} -I. ${CPPFLAGS}"
 129 ac_clean_files="ft2build.h ftoption.h ftstdlib.h"
 130 touch ft2build.h ftoption.h ftstdlib.h
 131
 132 cat > conftest.c <<\_ACEOF
 133 #include <limits.h>
 134 #define FT_CONFIG_OPTIONS_H "ftoption.h"
 135 #define FT_CONFIG_STANDARD_LIBRARY_H "ftstdlib.h"
 136 #define FT_UINT_MAX  UINT_MAX
 137 #define FT_ULONG_MAX ULONG_MAX
 138 #include "ftconfig.in"
 139 _ACEOF
 140 echo >> conftest.c "#if FT_SIZEOF_INT == "${ac_cv_sizeof_int}
 141 echo >> conftest.c "ac_cpp_ft_sizeof_int="${ac_cv_sizeof_int}
 142 echo >> conftest.c "#endif"
 143 echo >> conftest.c "#if FT_SIZEOF_LONG == "${ac_cv_sizeof_long}
 144 echo >> conftest.c "ac_cpp_ft_sizeof_long="${ac_cv_sizeof_long}
 145 echo >> conftest.c "#endif"
 146
 147 ${CPP} ${CPPFLAGS} conftest.c | ${GREP} ac_cpp_ft > conftest.sh
 148 eval `cat conftest.sh`
 149 ${RMF} conftest.c conftest.sh confft2build.h ftoption.h ftstdlib.h
 150
 151 if test x != "x${ac_cpp_ft_sizeof_int}" \
 152    -a x != x"${ac_cpp_ft_sizeof_long}"; then
 153   unset ft_use_autoconf_sizeof_types
 154 else
 155   ft_use_autoconf_sizeof_types=yes
 156 fi
 157
 158 AC_ARG_ENABLE(biarch-config,
 159 [  --enable-biarch-config  install biarch ftconfig.h to support multiple
 160                           architectures by single file], [], [])
 161
 162 case :${ft_use_autoconf_sizeof_types}:${enable_biarch_config}: in
 163   :yes:yes:)
 164     AC_MSG_RESULT([broken but use it])
 165     unset ft_use_autoconf_sizeof_types
 166     ;;
 167   ::no:)
 168     AC_MSG_RESULT([works but ignore it])
 169     ft_use_autoconf_sizeof_types=yes
 170     ;;
 171   ::yes: | :::)
 172     AC_MSG_RESULT([yes])
 173     unset ft_use_autoconf_sizeof_types
 174     ;;
 175   *)
 176     AC_MSG_RESULT([no])
 177     ft_use_autoconf_sizeof_types=yes
 178     ;;
 179 esac
 180
 181 if test x"${ft_use_autoconf_sizeof_types}" = xyes; then
 182   AC_DEFINE([FT_USE_AUTOCONF_SIZEOF_TYPES])
 183 fi
 184
 185 CPPFLAGS="${orig_CPPFLAGS}"
 186
 187
 188 # checks for library functions
 189
 190 # Here we check whether we can use our mmap file component.
 191
 192 AC_FUNC_MMAP
 193 if test "$ac_cv_func_mmap_fixed_mapped" != yes; then
 194   FTSYS_SRC='$(BASE_DIR)/ftsystem.c'
 195 else
 196   FTSYS_SRC='$(BUILD_DIR)/ftsystem.c'
 197
 198   AC_CHECK_DECLS([munmap],
 199     [],
 200     [],
 201     [
 202
 203 #ifdef HAVE_UNISTD_H
 204 #include <unistd.h>
 205 #endif
 206 #include <sys/mman.h>
 207
 208     ])
 209
 210   FT_MUNMAP_PARAM
 211 fi
 212 AC_SUBST([FTSYS_SRC])
 213
 214 AC_CHECK_FUNCS([memcpy memmove])
 215
 216
 217 # check for system zlib
 218
 219 # don't quote AS_HELP_STRING!
 220 AC_ARG_WITH([zlib],
 221   AS_HELP_STRING([--without-zlib],
 222                  [use internal zlib instead of system-wide]))
 223 if test x$with_zlib != xno && test -z "$LIBZ"; then
 224   AC_CHECK_LIB([z], [gzsetparams], [AC_CHECK_HEADER([zlib.h], [LIBZ='-lz'])])
 225 fi
 226 if test x$with_zlib != xno && test -n "$LIBZ"; then
 227   CFLAGS="$CFLAGS -DFT_CONFIG_OPTION_SYSTEM_ZLIB"
 228   LDFLAGS="$LDFLAGS $LIBZ"
 229   SYSTEM_ZLIB=yes
 230 fi
 231
 232
 233 # Some options handling SDKs/archs in CFLAGS should be copied
 234 # to LDFLAGS. Apple TechNote 2137 recommends to include these
 235 # options in CFLAGS but not in LDFLAGS.
 236
 237 save_config_args=$*
 238 set dummy ${CFLAGS}
 239 i=1
 240 while test $i -lt $#
 241 do
 242   c=$1
 243
 244   case "${c}" in
 245   -isysroot|-arch) # options taking 1 argument
 246     a=$2
 247     AC_MSG_CHECKING([whether CFLAGS and LDFLAGS share ${c} ${a}])
 248     if expr " ${LDFLAGS} " : ".* ${c} *${a}.*" > /dev/null
 249     then
 250       AC_MSG_RESULT([yes])
 251     else
 252       AC_MSG_RESULT([no, copy to LDFLAGS])
 253       LDFLAGS="${LDFLAGS} ${c} ${a}"
 254     fi
 255     shift 1
 256     ;;
 257   -m32|-m64) # options taking no argument
 258     AC_MSG_RESULT([whether CFLAGS and LDFLAGS share ${c}])
 259     if expr " ${LDFLAGS} " : ".* ${c} *${a}.*" > /dev/null
 260     then
 261       AC_MSG_RESULT([yes])
 262     else
 263       AC_MSG_RESULT([no, copy to LDFLAGS])
 264       LDFLAGS="${LDFLAGS} ${c}"
 265     fi
 266     ;;
 267   # *)
 268   #   AC_MSG_RESULT([${c} is not copied to LDFLAGS])
 269   #   ;;
 270   esac
 271
 272   shift 1
 273 done
 274 set ${save_config_args}
 275
 276
 277 # Whether to use Mac OS resource-based fonts.
 278
 279 ftmac_c="" # src/base/ftmac.c should not be included in makefiles by default
 280
 281 # don't quote AS_HELP_STRING!
 282 AC_ARG_WITH([old-mac-fonts],
 283   AS_HELP_STRING([--with-old-mac-fonts],
 284                  [allow Mac resource-based fonts to be used]))
 285 if test x$with_old_mac_fonts = xyes; then
 286   orig_LDFLAGS="${LDFLAGS}"
 287   AC_MSG_CHECKING([CoreServices & ApplicationServices of Mac OS X])
 288   FT2_EXTRA_LIBS="-Wl,-framework,CoreServices -Wl,-framework,ApplicationServices"
 289   LDFLAGS="$LDFLAGS $FT2_EXTRA_LIBS"
 290   AC_LINK_IFELSE([
 291     AC_LANG_PROGRAM([
 292
 293 #if defined(__GNUC__) && defined(__APPLE_CC__)
 294 # include <CoreServices/CoreServices.h>
 295 # include <ApplicationServices/ApplicationServices.h>
 296 #else
 297 # include <ConditionalMacros.h>
 298 # include <Files.h>
 299 #endif
 300
 301       ],
 302       [
 303
 304         short res = 0;
 305
 306
 307         UseResFile( res );
 308
 309       ])],
 310     [AC_MSG_RESULT([ok])
 311      ftmac_c='ftmac.c'
 312      AC_MSG_CHECKING([OS_INLINE macro is ANSI compatible])
 313      orig_CFLAGS="$CFLAGS"
 314      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 315      AC_COMPILE_IFELSE([
 316        AC_LANG_PROGRAM([
 317
 318 #if defined(__GNUC__) && defined(__APPLE_CC__)
 319 # include <CoreServices/CoreServices.h>
 320 # include <ApplicationServices/ApplicationServices.h>
 321 #else
 322 # include <ConditionalMacros.h>
 323 # include <Files.h>
 324 #endif
 325
 326          ],
 327          [
 328
 329            /* OSHostByteOrder() is typed as OS_INLINE */
 330            int32_t  os_byte_order = OSHostByteOrder();
 331
 332
 333            if ( OSBigEndian != os_byte_order )
 334              return 1;
 335
 336          ])],
 337        [AC_MSG_RESULT([ok])
 338         CFLAGS="$orig_CFLAGS"
 339         CFLAGS="$CFLAGS -DHAVE_ANSI_OS_INLINE=1"
 340        ],
 341        [AC_MSG_RESULT([no, ANSI incompatible])
 342         CFLAGS="$orig_CFLAGS"
 343        ])
 344      AC_MSG_CHECKING([type ResourceIndex])
 345      orig_CFLAGS="$CFLAGS"
 346      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 347      AC_COMPILE_IFELSE([
 348        AC_LANG_PROGRAM([
 349
 350 #if defined(__GNUC__) && defined(__APPLE_CC__)
 351 # include <CoreServices/CoreServices.h>
 352 # include <ApplicationServices/ApplicationServices.h>
 353 #else
 354 # include <ConditionalMacros.h>
 355 # include <Files.h>
 356 # include <Resources.h>
 357 #endif
 358
 359          ],
 360          [
 361
 362            ResourceIndex i = 0;
 363            return i;
 364
 365          ])],
 366        [AC_MSG_RESULT([ok])
 367         CFLAGS="$orig_CFLAGS"
 368         CFLAGS="$CFLAGS -DHAVE_TYPE_RESOURCE_INDEX=1"
 369        ],
 370        [AC_MSG_RESULT([no])
 371         CFLAGS="$orig_CFLAGS"
 372         CFLAGS="$CFLAGS -DHAVE_TYPE_RESOURCE_INDEX=0"
 373        ])],
 374     [AC_MSG_RESULT([not found])
 375      FT2_EXTRA_LIBS=""
 376      LDFLAGS="${orig_LDFLAGS}"
 377      CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"])
 378 else
 379   case x$host_os in
 380   xdarwin*)
 381     dnl AC_MSG_WARN([host system is MacOS but configured to build without Carbon])
 382     CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"
 383     ;;
 384   *) ;;
 385   esac
 386 fi
 387
 388
 389 # Whether to use FileManager which is deprecated since Mac OS X 10.4.
 390
 391 AC_ARG_WITH([fsspec],
 392   AS_HELP_STRING([--with-fsspec],
 393                  [use obsolete FSSpec API of MacOS, if available (default=yes)]))
 394 if test x$with_fsspec = xno; then
 395   CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"
 396 elif test x$with_old_mac_fonts = xyes -a x$with_fsspec != x; then
 397   AC_MSG_CHECKING([FSSpec-based FileManager])
 398   AC_LINK_IFELSE([
 399     AC_LANG_PROGRAM([
 400
 401 #if defined(__GNUC__) && defined(__APPLE_CC__)
 402 # include <CoreServices/CoreServices.h>
 403 # include <ApplicationServices/ApplicationServices.h>
 404 #else
 405 # include <ConditionalMacros.h>
 406 # include <Files.h>
 407 #endif
 408
 409       ],
 410       [
 411
 412         FCBPBPtr          paramBlock;
 413         short             vRefNum;
 414         long              dirID;
 415         ConstStr255Param  fileName;
 416         FSSpec*           spec;
 417
 418
 419         /* FSSpec functions: deprecated since Mac OS X 10.4 */
 420         PBGetFCBInfoSync( paramBlock );
 421         FSMakeFSSpec( vRefNum, dirID, fileName, spec );
 422
 423       ])],
 424     [AC_MSG_RESULT([ok])
 425      CFLAGS="$CFLAGS -DHAVE_FSSPEC=1"],
 426     [AC_MSG_RESULT([not found])
 427      CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"])
 428 fi
 429
 430
 431 # Whether to use FileManager in Carbon since MacOS 9.x.
 432
 433 AC_ARG_WITH([fsref],
 434   AS_HELP_STRING([--with-fsref],
 435                  [use Carbon FSRef API of MacOS, if available (default=yes)]))
 436 if test x$with_fsref = xno; then
 437   AC_MSG_WARN([
 438 *** WARNING
 439     FreeType2 built without FSRef API cannot load
 440     data-fork fonts on MacOS, except of XXX.dfont.
 441     ])
 442   CFLAGS="$CFLAGS -DHAVE_FSREF=0"
 443 elif test x$with_old_mac_fonts = xyes -a x$with_fsref != x; then
 444   AC_MSG_CHECKING([FSRef-based FileManager])
 445   AC_LINK_IFELSE([
 446     AC_LANG_PROGRAM([
 447
 448 #if defined(__GNUC__) && defined(__APPLE_CC__)
 449 # include <CoreServices/CoreServices.h>
 450 # include <ApplicationServices/ApplicationServices.h>
 451 #else
 452 # include <ConditionalMacros.h>
 453 # include <Files.h>
 454 #endif
 455
 456       ],
 457       [
 458
 459         short                vRefNum;
 460         long                 dirID;
 461         ConstStr255Param     fileName;
 462
 463         Boolean*             isDirectory;
 464         UInt8*               path;
 465         SInt16               desiredRefNum;
 466         SInt16*              iterator;
 467         SInt16*              actualRefNum;
 468         HFSUniStr255*        outForkName;
 469         FSVolumeRefNum       volume;
 470         FSCatalogInfoBitmap  whichInfo;
 471         FSCatalogInfo*       catalogInfo;
 472         FSForkInfo*          forkInfo;
 473         FSRef*               ref;
 474
 475 #if HAVE_FSSPEC
 476         FSSpec*              spec;
 477 #endif
 478
 479         /* FSRef functions: no need to check? */
 480         FSGetForkCBInfo( desiredRefNum, volume, iterator,
 481                          actualRefNum, forkInfo, ref,
 482                          outForkName );
 483         FSPathMakeRef( path, ref, isDirectory );
 484
 485 #if HAVE_FSSPEC
 486         FSpMakeFSRef ( spec, ref );
 487         FSGetCatalogInfo( ref, whichInfo, catalogInfo,
 488                           outForkName, spec, ref );
 489 #endif
 490       ])],
 491     [AC_MSG_RESULT([ok])
 492      CFLAGS="$CFLAGS -DHAVE_FSREF=1"],
 493     [AC_MSG_RESULT([not found])
 494      CFLAGS="$CFLAGS -DHAVE_FSREF=0"])
 495 fi
 496
 497
 498 # Whether to use QuickDraw API in ToolBox which is deprecated since
 499 # Mac OS X 10.4.
 500
 501 AC_ARG_WITH([quickdraw-toolbox],
 502   AS_HELP_STRING([--with-quickdraw-toolbox],
 503                  [use MacOS QuickDraw in ToolBox, if available (default=yes)]))
 504 if test x$with_quickdraw_toolbox = xno; then
 505   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"
 506 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_toolbox != x; then
 507   AC_MSG_CHECKING([QuickDraw FontManager functions in ToolBox])
 508   AC_LINK_IFELSE([
 509     AC_LANG_PROGRAM([
 510
 511 #if defined(__GNUC__) && defined(__APPLE_CC__)
 512 # include <CoreServices/CoreServices.h>
 513 # include <ApplicationServices/ApplicationServices.h>
 514 #else
 515 # include <ConditionalMacros.h>
 516 # include <Fonts.h>
 517 #endif
 518
 519       ],
 520       [
 521
 522         Str255     familyName;
 523         SInt16     familyID   = 0;
 524         FMInput*   fmIn       = NULL;
 525         FMOutput*  fmOut      = NULL;
 526
 527
 528         GetFontName( familyID, familyName );
 529         GetFNum( familyName, &familyID );
 530         fmOut = FMSwapFont( fmIn );
 531
 532       ])],
 533     [AC_MSG_RESULT([ok])
 534      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=1"],
 535     [AC_MSG_RESULT([not found])
 536      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"])
 537 fi
 538
 539
 540 # Whether to use QuickDraw API in Carbon which is deprecated since
 541 # Mac OS X 10.4.
 542
 543 AC_ARG_WITH([quickdraw-carbon],
 544   AS_HELP_STRING([--with-quickdraw-carbon],
 545                  [use MacOS QuickDraw in Carbon, if available (default=yes)]))
 546 if test x$with_quickdraw_carbon = xno; then
 547   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"
 548 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_carbon != x; then
 549   AC_MSG_CHECKING([QuickDraw FontManager functions in Carbon])
 550   AC_LINK_IFELSE([
 551     AC_LANG_PROGRAM([
 552
 553 #if defined(__GNUC__) && defined(__APPLE_CC__)
 554 # include <CoreServices/CoreServices.h>
 555 # include <ApplicationServices/ApplicationServices.h>
 556 #else
 557 # include <ConditionalMacros.h>
 558 # include <Fonts.h>
 559 #endif
 560
 561       ],
 562       [
 563
 564         FMFontFamilyIterator          famIter;
 565         FMFontFamily                  family;
 566         Str255                        famNameStr;
 567         FMFontFamilyInstanceIterator  instIter;
 568         FMFontStyle                   style;
 569         FMFontSize                    size;
 570         FMFont                        font;
 571         FSSpec*                       pathSpec;
 572
 573
 574         FMCreateFontFamilyIterator( NULL, NULL, kFMUseGlobalScopeOption,
 575                                     &famIter );
 576         FMGetNextFontFamily( &famIter, &family );
 577         FMGetFontFamilyName( family, famNameStr );
 578         FMCreateFontFamilyInstanceIterator( family, &instIter );
 579         FMGetNextFontFamilyInstance( &instIter, &font, &style, &size );
 580         FMDisposeFontFamilyInstanceIterator( &instIter );
 581         FMDisposeFontFamilyIterator( &famIter );
 582         FMGetFontContainer( font, pathSpec );
 583
 584       ])],
 585     [AC_MSG_RESULT([ok])
 586      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=1"],
 587     [AC_MSG_RESULT([not found])
 588      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"])
 589 fi
 590
 591
 592 # Whether to use AppleTypeService since Mac OS X.
 593
 594 # don't quote AS_HELP_STRING!
 595 AC_ARG_WITH([ats],
 596   AS_HELP_STRING([--with-ats],
 597                  [use AppleTypeService, if available (default=yes)]))
 598 if test x$with_ats = xno; then
 599   CFLAGS="$CFLAGS -DHAVE_ATS=0"
 600 elif test x$with_old_mac_fonts = xyes -a x$with_ats != x ; then
 601   AC_MSG_CHECKING([AppleTypeService functions])
 602   AC_LINK_IFELSE([
 603     AC_LANG_PROGRAM([
 604
 605 #if defined(__GNUC__) && defined(__APPLE_CC__)
 606 # include <CoreServices/CoreServices.h>
 607 # include <ApplicationServices/ApplicationServices.h>
 608 #else
 609 # include <ConditionalMacros.h>
 610 # include <Files.h>
 611 #endif
 612
 613       ],
 614       [
 615
 616         FSSpec*  pathSpec;
 617
 618
 619         ATSFontFindFromName( NULL, kATSOptionFlagsUnRestrictedScope );
 620 #if HAVE_FSSPEC
 621         ATSFontGetFileSpecification( 0, pathSpec );
 622 #endif
 623
 624       ])],
 625     [AC_MSG_RESULT([ok])
 626      CFLAGS="$CFLAGS -DHAVE_ATS=1"],
 627     [AC_MSG_RESULT([not found])
 628      CFLAGS="$CFLAGS -DHAVE_ATS=0"])
 629 fi
 630
 631 case "$CFLAGS" in
 632   *HAVE_FSSPEC* | *HAVE_FSREF* | *HAVE_QUICKDRAW* | *HAVE_ATS* )
 633     AC_MSG_WARN([
 634 *** WARNING
 635     FSSpec/FSRef/QuickDraw/ATS options are explicitly given,
 636     thus it is recommended to replace src/base/ftmac.c by builds/mac/ftmac.c.
 637     ])
 638     CFLAGS="$CFLAGS "'-I$(TOP_DIR)/builds/mac/'
 639     ;;
 640   *)
 641     ;;
 642 esac
 643
 644
 645 AC_SUBST([ftmac_c])
 646 AC_SUBST([LIBZ])
 647 AC_SUBST([CFLAGS])
 648 AC_SUBST([LDFLAGS])
 649 AC_SUBST([FT2_EXTRA_LIBS])
 650 AC_SUBST([SYSTEM_ZLIB])
 651
 652
 653 LT_INIT(win32-dll)
 654
 655 AC_SUBST([hardcode_libdir_flag_spec])
 656 AC_SUBST([wl])
 657 AC_SUBST([build_libtool_libs])
 658
 659
 660 # configuration file -- stay in 8.3 limit
 661 #
 662 # since #undef doesn't survive in configuration header files we replace
 663 # `/undef' with `#undef' after creating the output file
 664
 665 AC_CONFIG_HEADERS([ftconfig.h:ftconfig.in],
 666   [mv ftconfig.h ftconfig.tmp
 667    sed 's|/undef|#undef|' < ftconfig.tmp > ftconfig.h
 668    rm ftconfig.tmp])
 669
 670 # create the Unix-specific sub-Makefiles `builds/unix/unix-def.mk'
 671 # and `builds/unix/unix-cc.mk' that will be used by the build system
 672 #
 673 AC_CONFIG_FILES([unix-cc.mk:unix-cc.in
 674                  unix-def.mk:unix-def.in
 675                  freetype-config
 676                  freetype2.pc:freetype2.in])
 677
 678 # re-generate the Jamfile to use libtool now
 679 #
 680 # AC_CONFIG_FILES([../../Jamfile:../../Jamfile.in])
 681
 682 AC_OUTPUT
 683
 684 # end of configure.raw