modules/freetype2/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 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.3.7], [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='9:18:3'
  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_BUILD
  29 AC_CANONICAL_HOST
  30 AC_CANONICAL_TARGET
  31
  32
  33 # checks for programs
  34
  35 AC_PROG_CC
  36 AC_PROG_CPP
  37 AC_SUBST(EXEEXT)
  38
  39
  40 # checks for native programs to generate building tool
  41
  42 if test ${cross_compiling} = yes; then
  43   AC_CHECK_PROG(CC_BUILD, ${build}-gcc, ${build}-gcc)
  44   test -z "${CC_BUILD}" && AC_CHECK_PROG(CC_BUILD, gcc, gcc)
  45   test -z "${CC_BUILD}" && AC_CHECK_PROG(CC_BUILD, cc, cc, , , /usr/ucb/cc)
  46   test -z "${CC_BUILD}" && AC_MSG_ERROR([cannot find native C compiler])
  47
  48   AC_MSG_CHECKING([for suffix of native executables])
  49   rm -f a.* b.* a_out.exe conftest.*
  50   echo > conftest.c "int main() { return 0;}"
  51   ${CC_BUILD} conftest.c || AC_MSG_ERROR([native C compiler is not working])
  52   rm -f conftest.c
  53   if test -x a.out -o -x b.out -o -x conftest; then
  54     EXEEXT_BUILD=""
  55   elif test -x a_out.exe -o -x conftest.exe; then
  56     EXEEXT_BUILD=".exe"
  57   elif test -x conftest.* ; then
  58     EXEEXT_BUILD=`echo conftest.* | sed -n '1s/^.*\.//g'`
  59   fi
  60   AC_MSG_RESULT($EXEEXT_BUILD)
  61 else
  62   CC_BUILD=${CC}
  63   EXEEXT_BUILD=${EXEEXT}
  64 fi
  65
  66
  67 if test ! -z ${EXEEXT_BUILD}; then
  68   EXEEXT_BUILD=."${EXEEXT_BUILD}"
  69 fi
  70 AC_SUBST(CC_BUILD)
  71 AC_SUBST(EXEEXT_BUILD)
  72
  73
  74
  75 # get compiler flags right
  76
  77 if test "x$CC" = xgcc; then
  78   XX_CFLAGS="-Wall"
  79   XX_ANSIFLAGS="-pedantic -ansi"
  80 else
  81   case "$host" in
  82   *-dec-osf*)
  83     CFLAGS=
  84     XX_CFLAGS="-std1 -g3"
  85     XX_ANSIFLAGS=
  86     ;;
  87   *)
  88     XX_CFLAGS=
  89     XX_ANSIFLAGS=
  90     ;;
  91   esac
  92 fi
  93 AC_SUBST([XX_CFLAGS])
  94 AC_SUBST([XX_ANSIFLAGS])
  95
  96
  97 # auxiliary programs
  98
  99 AC_CHECK_PROG([RMF], [rm], [rm -f])
 100 AC_CHECK_PROG([RMDIR], [rmdir], [rmdir])
 101
 102
 103 # Since this file will be finally moved to another directory we make
 104 # the path of the install script absolute.  This small code snippet has
 105 # been taken from automake's `ylwrap' script.
 106
 107 AC_PROG_INSTALL
 108 case "$INSTALL" in
 109 /*)
 110   ;;
 111 */*)
 112   INSTALL="`pwd`/$INSTALL" ;;
 113 esac
 114
 115
 116 # checks for header files
 117
 118 AC_HEADER_STDC
 119 AC_CHECK_HEADERS([fcntl.h unistd.h])
 120
 121
 122 # checks for typedefs, structures, and compiler characteristics
 123
 124 AC_C_CONST
 125 AC_CHECK_SIZEOF([int])
 126 AC_CHECK_SIZEOF([long])
 127
 128
 129 # checks for library functions
 130
 131 # Here we check whether we can use our mmap file component.
 132
 133 AC_FUNC_MMAP
 134 if test "$ac_cv_func_mmap_fixed_mapped" != yes; then
 135   FTSYS_SRC='$(BASE_DIR)/ftsystem.c'
 136 else
 137   FTSYS_SRC='$(BUILD_DIR)/ftsystem.c'
 138
 139   AC_CHECK_DECLS([munmap],
 140     [],
 141     [],
 142     [
 143
 144 #ifdef HAVE_UNISTD_H
 145 #include <unistd.h>
 146 #endif
 147 #include <sys/mman.h>
 148
 149     ])
 150
 151   FT_MUNMAP_PARAM
 152 fi
 153 AC_SUBST([FTSYS_SRC])
 154
 155 AC_CHECK_FUNCS([memcpy memmove])
 156
 157
 158 # check for system zlib
 159
 160 # don't quote AS_HELP_STRING!
 161 AC_ARG_WITH([zlib],
 162   AS_HELP_STRING([--without-zlib],
 163                  [use internal zlib instead of system-wide]))
 164 if test x$with_zlib != xno && test -z "$LIBZ"; then
 165   AC_CHECK_LIB([z], [gzsetparams], [AC_CHECK_HEADER([zlib.h], [LIBZ='-lz'])])
 166 fi
 167 if test x$with_zlib != xno && test -n "$LIBZ"; then
 168   CFLAGS="$CFLAGS -DFT_CONFIG_OPTION_SYSTEM_ZLIB"
 169   LDFLAGS="$LDFLAGS $LIBZ"
 170   SYSTEM_ZLIB=yes
 171 fi
 172
 173
 174 # check Apple's `-isysroot' option and duplicate it to LDFLAGS if required --
 175 # Apple TechNote 2137 recommends to include it in CFLAGS but not in LDFLAGS
 176
 177 AC_MSG_CHECKING([whether CFLAGS includes -isysroot option])
 178 case "$CFLAGS" in
 179 *sysroot* )
 180   AC_MSG_RESULT([yes])
 181   AC_MSG_CHECKING([whether LDFLAGS includes -isysroot option])
 182   case "$LDFLAGS" in
 183   *sysroot* )
 184     AC_MSG_RESULT([yes])
 185     ;;
 186   *)
 187     AC_MSG_RESULT([no])
 188     isysroot_dir=`echo ${CFLAGS} | tr '\t' ' ' | sed 's/^.*-isysroot *//;s/ .*//'`
 189     AC_MSG_WARN(-isysroot ${isysroot_dir} is added to LDFLAGS)
 190     LDFLAGS="-isysroot ${isysroot_dir} ${LDFLAGS}"
 191     ;;
 192   esac
 193   ;;
 194 *)
 195   AC_MSG_RESULT([no])
 196   ;;
 197 esac
 198
 199
 200 # Whether to use Mac OS resource-based fonts.
 201
 202 # don't quote AS_HELP_STRING!
 203 AC_ARG_WITH([old-mac-fonts],
 204   AS_HELP_STRING([--with-old-mac-fonts],
 205                  [allow Mac resource-based fonts to be used]))
 206 if test x$with_old_mac_fonts = xyes; then
 207   orig_LDFLAGS="${LDFLAGS}"
 208   AC_MSG_CHECKING([CoreServices & ApplicationServices of Mac OS X])
 209   FT2_EXTRA_LIBS="-Wl,-framework,CoreServices -Wl,-framework,ApplicationServices"
 210   LDFLAGS="$LDFLAGS $FT2_EXTRA_LIBS"
 211   AC_LINK_IFELSE([
 212     AC_LANG_PROGRAM([
 213
 214 #if defined(__GNUC__) && defined(__APPLE_CC__)
 215 # include <Carbon/Carbon.h>
 216 # include <ApplicationServices/ApplicationServices.h>
 217 #else
 218 # include <ConditionalMacros.h>
 219 # include <Files.h>
 220 #endif
 221
 222       ],
 223       [
 224
 225         short res = 0;
 226
 227
 228         UseResFile( res );
 229
 230       ])],
 231     [AC_MSG_RESULT([ok])
 232      AC_MSG_CHECKING([OS_INLINE macro is ANSI compatible])
 233      orig_CFLAGS="$CFLAGS"
 234      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 235      AC_COMPILE_IFELSE([
 236        AC_LANG_PROGRAM([
 237
 238 #if defined(__GNUC__) && defined(__APPLE_CC__)
 239 # include <Carbon/Carbon.h>
 240 # include <ApplicationServices/ApplicationServices.h>
 241 #else
 242 # include <ConditionalMacros.h>
 243 # include <Files.h>
 244 #endif
 245
 246          ],
 247          [
 248
 249            /* OSHostByteOrder() is typed as OS_INLINE */
 250            int32_t  os_byte_order = OSHostByteOrder();
 251
 252
 253            if ( OSBigEndian != os_byte_order )
 254              return 1;
 255
 256          ])],
 257        [AC_MSG_RESULT([ok])
 258         CFLAGS="$orig_CFLAGS"
 259         CFLAGS="$CFLAGS -DHAVE_ANSI_OS_INLINE=1"
 260        ],
 261        [AC_MSG_RESULT([no, ANSI incompatible])
 262         CFLAGS="$orig_CFLAGS"
 263        ])
 264      AC_MSG_CHECKING([type ResourceIndex])
 265      orig_CFLAGS="$CFLAGS"
 266      CFLAGS="$CFLAGS $XX_CFLAGS $XX_ANSIFLAGS"
 267      AC_COMPILE_IFELSE([
 268        AC_LANG_PROGRAM([
 269
 270 #if defined(__GNUC__) && defined(__APPLE_CC__)
 271 # include <Carbon/Carbon.h>
 272 # include <ApplicationServices/ApplicationServices.h>
 273 #else
 274 # include <ConditionalMacros.h>
 275 # include <Files.h>
 276 # include <Resources.h>
 277 #endif
 278
 279          ],
 280          [
 281
 282            ResourceIndex i = 0;
 283            return i;
 284
 285          ])],
 286        [AC_MSG_RESULT([ok])
 287         CFLAGS="$orig_CFLAGS"
 288         CFLAGS="$CFLAGS -DHAVE_TYPE_RESOURCE_INDEX"
 289        ],
 290        [AC_MSG_RESULT([no])
 291         CFLAGS="$orig_CFLAGS"
 292        ])],
 293     [AC_MSG_RESULT([not found])
 294      LDFLAGS="${orig_LDFLAGS}"
 295      CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"])
 296 else
 297   case x$target_os in
 298   xdarwin*)
 299     dnl AC_MSG_WARN([target system is MacOS but configured to build without Carbon])
 300     CFLAGS="$CFLAGS -DDARWIN_NO_CARBON"
 301     ;;
 302   *) ;;
 303   esac
 304 fi
 305
 306
 307 # Whether to use FileManager which is deprecated since Mac OS X 10.4.
 308
 309 AC_ARG_WITH([fsspec],
 310   AS_HELP_STRING([--with-fsspec],
 311                  [use obsolete FSSpec API of MacOS, if available (default=yes)]))
 312 if test x$with_fsspec = xno; then
 313   CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"
 314 elif test x$with_old_mac_fonts = xyes -a x$with_fsspec != x; then
 315   AC_MSG_CHECKING([FSSpec-based FileManager])
 316   AC_LINK_IFELSE([
 317     AC_LANG_PROGRAM([
 318
 319 #if defined(__GNUC__) && defined(__APPLE_CC__)
 320 # include <Carbon/Carbon.h>
 321 # include <ApplicationServices/ApplicationServices.h>
 322 #else
 323 # include <ConditionalMacros.h>
 324 # include <Files.h>
 325 #endif
 326
 327       ],
 328       [
 329
 330         FCBPBPtr          paramBlock;
 331         short             vRefNum;
 332         long              dirID;
 333         ConstStr255Param  fileName;
 334         FSSpec*           spec;
 335
 336
 337         /* FSSpec functions: deprecated since Mac OS X 10.4 */
 338         PBGetFCBInfoSync( paramBlock );
 339         FSMakeFSSpec( vRefNum, dirID, fileName, spec );
 340
 341       ])],
 342     [AC_MSG_RESULT([ok])
 343      CFLAGS="$CFLAGS -DHAVE_FSSPEC=1"],
 344     [AC_MSG_RESULT([not found])
 345      CFLAGS="$CFLAGS -DHAVE_FSSPEC=0"])
 346 fi
 347
 348
 349 # Whether to use FileManager in Carbon since MacOS 9.x.
 350
 351 AC_ARG_WITH([fsref],
 352   AS_HELP_STRING([--with-fsref],
 353                  [use Carbon FSRef API of MacOS, if available (default=yes)]))
 354 if test x$with_fsref = xno; then
 355   AC_MSG_WARN([
 356 *** WARNING
 357     FreeType2 built without FSRef API cannot load
 358     data-fork fonts on MacOS, except of XXX.dfont.
 359     ])
 360   CFLAGS="$CFLAGS -DHAVE_FSREF=0"
 361 elif test x$with_old_mac_fonts = xyes -a x$with_fsref != x; then
 362   AC_MSG_CHECKING([FSRef-based FileManager])
 363   AC_LINK_IFELSE([
 364     AC_LANG_PROGRAM([
 365
 366 #if defined(__GNUC__) && defined(__APPLE_CC__)
 367 # include <Carbon/Carbon.h>
 368 # include <ApplicationServices/ApplicationServices.h>
 369 #else
 370 # include <ConditionalMacros.h>
 371 # include <Files.h>
 372 #endif
 373
 374       ],
 375       [
 376
 377         short                vRefNum;
 378         long                 dirID;
 379         ConstStr255Param     fileName;
 380
 381         Boolean*             isDirectory;
 382         UInt8*               path;
 383         SInt16               desiredRefNum;
 384         SInt16*              iterator;
 385         SInt16*              actualRefNum;
 386         HFSUniStr255*        outForkName;
 387         FSVolumeRefNum       volume;
 388         FSCatalogInfoBitmap  whichInfo;
 389         FSCatalogInfo*       catalogInfo;
 390         FSForkInfo*          forkInfo;
 391         FSRef*               ref;
 392
 393 #if HAVE_FSSPEC
 394         FSSpec*              spec;
 395 #endif
 396
 397         /* FSRef functions: no need to check? */
 398         FSGetForkCBInfo( desiredRefNum, volume, iterator,
 399                          actualRefNum, forkInfo, ref,
 400                          outForkName );
 401         FSPathMakeRef( path, ref, isDirectory );
 402
 403 #if HAVE_FSSPEC
 404         FSpMakeFSRef ( spec, ref );
 405         FSGetCatalogInfo( ref, whichInfo, catalogInfo,
 406                           outForkName, spec, ref );
 407 #endif
 408       ])],
 409     [AC_MSG_RESULT([ok])
 410      CFLAGS="$CFLAGS -DHAVE_FSREF=1"],
 411     [AC_MSG_RESULT([not found])
 412      CFLAGS="$CFLAGS -DHAVE_FSREF=0"])
 413 fi
 414
 415
 416 # Whether to use QuickDraw API in ToolBox which is deprecated since
 417 # Mac OS X 10.4.
 418
 419 AC_ARG_WITH([quickdraw-toolbox],
 420   AS_HELP_STRING([--with-quickdraw-toolbox],
 421                  [use MacOS QuickDraw in ToolBox, if available (default=yes)]))
 422 if test x$with_quickdraw_toolbox = xno; then
 423   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"
 424 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_toolbox != x; then
 425   AC_MSG_CHECKING([QuickDraw FontManager functions in ToolBox])
 426   AC_LINK_IFELSE([
 427     AC_LANG_PROGRAM([
 428
 429 #if defined(__GNUC__) && defined(__APPLE_CC__)
 430 # include <Carbon/Carbon.h>
 431 # include <ApplicationServices/ApplicationServices.h>
 432 #else
 433 # include <ConditionalMacros.h>
 434 # include <Fonts.h>
 435 #endif
 436
 437       ],
 438       [
 439
 440         Str255     familyName;
 441         SInt16     familyID   = 0;
 442         FMInput*   fmIn       = NULL;
 443         FMOutput*  fmOut      = NULL;
 444
 445
 446         GetFontName( familyID, familyName );
 447         GetFNum( familyName, &familyID );
 448         fmOut = FMSwapFont( fmIn );
 449
 450       ])],
 451     [AC_MSG_RESULT([ok])
 452      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=1"],
 453     [AC_MSG_RESULT([not found])
 454      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_TOOLBOX=0"])
 455 fi
 456
 457
 458 # Whether to use QuickDraw API in Carbon which is deprecated since
 459 # Mac OS X 10.4.
 460
 461 AC_ARG_WITH([quickdraw-carbon],
 462   AS_HELP_STRING([--with-quickdraw-carbon],
 463                  [use MacOS QuickDraw in Carbon, if available (default=yes)]))
 464 if test x$with_quickdraw_carbon = xno; then
 465   CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"
 466 elif test x$with_old_mac_fonts = xyes -a x$with_quickdraw_carbon != x; then
 467   AC_MSG_CHECKING([QuickDraw FontManager functions in Carbon])
 468   AC_LINK_IFELSE([
 469     AC_LANG_PROGRAM([
 470
 471 #if defined(__GNUC__) && defined(__APPLE_CC__)
 472 # include <Carbon/Carbon.h>
 473 # include <ApplicationServices/ApplicationServices.h>
 474 #else
 475 # include <ConditionalMacros.h>
 476 # include <Fonts.h>
 477 #endif
 478
 479       ],
 480       [
 481
 482         FMFontFamilyIterator          famIter;
 483         FMFontFamily                  family;
 484         Str255                        famNameStr;
 485         FMFontFamilyInstanceIterator  instIter;
 486         FMFontStyle                   style;
 487         FMFontSize                    size;
 488         FMFont                        font;
 489         FSSpec*                       pathSpec;
 490
 491
 492         FMCreateFontFamilyIterator( NULL, NULL, kFMUseGlobalScopeOption,
 493                                     &famIter );
 494         FMGetNextFontFamily( &famIter, &family );
 495         FMGetFontFamilyName( family, famNameStr );
 496         FMCreateFontFamilyInstanceIterator( family, &instIter );
 497         FMGetNextFontFamilyInstance( &instIter, &font, &style, &size );
 498         FMDisposeFontFamilyInstanceIterator( &instIter );
 499         FMDisposeFontFamilyIterator( &famIter );
 500         FMGetFontContainer( font, pathSpec );
 501
 502       ])],
 503     [AC_MSG_RESULT([ok])
 504      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=1"],
 505     [AC_MSG_RESULT([not found])
 506      CFLAGS="$CFLAGS -DHAVE_QUICKDRAW_CARBON=0"])
 507 fi
 508
 509
 510 # Whether to use AppleTypeService since Mac OS X.
 511
 512 # don't quote AS_HELP_STRING!
 513 AC_ARG_WITH([ats],
 514   AS_HELP_STRING([--with-ats],
 515                  [use AppleTypeService, if available (default=yes)]))
 516 if test x$with_ats = xno; then
 517   CFLAGS="$CFLAGS -DHAVE_ATS=0"
 518 elif test x$with_old_mac_fonts = xyes -a x$with_ats != x ; then
 519   AC_MSG_CHECKING([AppleTypeService functions])
 520   AC_LINK_IFELSE([
 521     AC_LANG_PROGRAM([
 522
 523 #include <Carbon/Carbon.h>
 524
 525       ],
 526       [
 527
 528         FSSpec*  pathSpec;
 529
 530
 531         ATSFontFindFromName( NULL, kATSOptionFlagsUnRestrictedScope );
 532 #if HAVE_FSSPEC
 533         ATSFontGetFileSpecification( 0, pathSpec );
 534 #endif
 535
 536       ])],
 537     [AC_MSG_RESULT([ok])
 538      CFLAGS="$CFLAGS -DHAVE_ATS=1"],
 539     [AC_MSG_RESULT([not found])
 540      CFLAGS="$CFLAGS -DHAVE_ATS=0"])
 541 fi
 542
 543 case "$CFLAGS" in
 544   *HAVE_FSSPEC* | *HAVE_FSREF* | *HAVE_QUICKDRAW* | *HAVE_ATS* )
 545     AC_MSG_WARN([
 546 *** WARNING
 547     FSSpec/FSRef/QuickDraw/ATS options are explicitly given,
 548     thus it is recommended to replace src/base/ftmac.c by builds/mac/ftmac.c.
 549     ])
 550     CFLAGS="$CFLAGS "'-I$(TOP_DIR)/builds/mac/'
 551     ;;
 552   *)
 553     ;;
 554 esac
 555
 556
 557 AC_SUBST([LIBZ])
 558 AC_SUBST([CFLAGS])
 559 AC_SUBST([LDFLAGS])
 560 AC_SUBST([FT2_EXTRA_LIBS])
 561 AC_SUBST([SYSTEM_ZLIB])
 562
 563
 564 LT_INIT(win32-dll)
 565
 566 AC_SUBST([hardcode_libdir_flag_spec])
 567 AC_SUBST([wl])
 568 AC_SUBST([build_libtool_libs])
 569
 570
 571 # configuration file -- stay in 8.3 limit
 572 #
 573 # since #undef doesn't survive in configuration header files we replace
 574 # `/undef' with `#undef' after creating the output file
 575
 576 AC_CONFIG_HEADERS([ftconfig.h:ftconfig.in],
 577   [mv ftconfig.h ftconfig.tmp
 578    sed 's|/undef|#undef|' < ftconfig.tmp > ftconfig.h
 579    rm ftconfig.tmp])
 580
 581 # create the Unix-specific sub-Makefiles `builds/unix/unix-def.mk'
 582 # and `builds/unix/unix-cc.mk' that will be used by the build system
 583 #
 584 AC_CONFIG_FILES([unix-cc.mk:unix-cc.in
 585                  unix-def.mk:unix-def.in
 586                  freetype-config
 587                  freetype2.pc:freetype2.in])
 588
 589 # re-generate the Jamfile to use libtool now
 590 #
 591 # AC_CONFIG_FILES([../../Jamfile:../../Jamfile.in])
 592
 593 AC_OUTPUT
 594
 595 # end of configure.raw