Edit

kc3-lang/freetype/builds/vms/ftconfig.h

Branch :

  • Show log

    Commit

  • Author : Werner Lemberg
    Date : 2008-10-04 11:39:03
    Hash : 45489589
    Message : * src/base/ftobjs.c (open_face_PS_from_sfnt_stream): Remove compiler warnings. Formatting.

  • builds/vms/ftconfig.h
  • /***************************************************************************/
    /*                                                                         */
    /*  ftconfig.h                                                             */
    /*                                                                         */
    /*    VMS-specific configuration file (specification only).                */
    /*                                                                         */
    /*  Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008 by             */
    /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    /*                                                                         */
    /*  This file is part of the FreeType project, and may only be used,       */
    /*  modified, and distributed under the terms of the FreeType project      */
    /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
    /*  this file you indicate that you have read the license and              */
    /*  understand and accept it fully.                                        */
    /*                                                                         */
    /***************************************************************************/
    
    
      /*************************************************************************/
      /*                                                                       */
      /* This header file contains a number of macro definitions that are used */
      /* by the rest of the engine.  Most of the macros here are automatically */
      /* determined at compile time, and you should not need to change it to   */
      /* port FreeType, except to compile the library with a non-ANSI          */
      /* compiler.                                                             */
      /*                                                                       */
      /* Note however that if some specific modifications are needed, we       */
      /* advise you to place a modified copy in your build directory.          */
      /*                                                                       */
      /* The build directory is usually `freetype/builds/<system>', and        */
      /* contains system-specific files that are always included first when    */
      /* building the library.                                                 */
      /*                                                                       */
      /*************************************************************************/
    
    
    #ifndef __FTCONFIG_H__
    #define __FTCONFIG_H__
    
    
      /* Include the header file containing all developer build options */
    #include <ft2build.h>
    #include FT_CONFIG_OPTIONS_H
    #include FT_CONFIG_STANDARD_LIBRARY_H
    
    
    FT_BEGIN_HEADER
    
      /*************************************************************************/
      /*                                                                       */
      /*               PLATFORM-SPECIFIC CONFIGURATION MACROS                  */
      /*                                                                       */
      /* These macros can be toggled to suit a specific system.  The current   */
      /* ones are defaults used to compile FreeType in an ANSI C environment   */
      /* (16bit compilers are also supported).  Copy this file to your own     */
      /* `freetype/builds/<system>' directory, and edit it to port the engine. */
      /*                                                                       */
      /*************************************************************************/
    
    
    #define HAVE_UNISTD_H  1
    #define HAVE_FCNTL_H   1
    
    #define SIZEOF_INT   4
    #define SIZEOF_LONG  4
    
    #define FT_SIZEOF_INT   4
    #define FT_SIZEOF_LONG  4
    
    #define FT_CHAR_BIT  8
    
    
      /* Preferred alignment of data */
    #define FT_ALIGNMENT  8
    
    
      /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
      /* used -- this is only used to get rid of unpleasant compiler warnings */
    #ifndef FT_UNUSED
    #define FT_UNUSED( arg )  ( (arg) = (arg) )
    #endif
    
    
      /*************************************************************************/
      /*                                                                       */
      /*                     AUTOMATIC CONFIGURATION MACROS                    */
      /*                                                                       */
      /* These macros are computed from the ones defined above.  Don't touch   */
      /* their definition, unless you know precisely what you are doing.  No   */
      /* porter should need to mess with them.                                 */
      /*                                                                       */
      /*************************************************************************/
    
    
      /*************************************************************************/
      /*                                                                       */
      /* Mac support                                                           */
      /*                                                                       */
      /*   This is the only necessary change, so it is defined here instead    */
      /*   providing a new configuration file.                                 */
      /*                                                                       */
    #if ( defined( __APPLE__ ) && !defined( DARWIN_NO_CARBON ) ) || \
        ( defined( __MWERKS__ ) && defined( macintosh )        )
      /* no Carbon frameworks for 64bit 10.4.x */
    #include "AvailabilityMacros.h"
    #if defined( __LP64__ ) && \
        ( MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4 )
    #define DARWIN_NO_CARBON 1
    #else
    #define FT_MACINTOSH 1
    #endif
    
    #elif defined( __SC__ ) || defined( __MRC__ )
      /* Classic MacOS compilers */
    #include "ConditionalMacros.h"
    #if TARGET_OS_MAC
    #define FT_MACINTOSH 1
    #endif
    
    #endif
    
    
      /*************************************************************************/
      /*                                                                       */
      /* IntN types                                                            */
      /*                                                                       */
      /*   Used to guarantee the size of some specific integers.               */
      /*                                                                       */
      typedef signed short    FT_Int16;
      typedef unsigned short  FT_UInt16;
    
    #if FT_SIZEOF_INT == 4
    
      typedef signed int      FT_Int32;
      typedef unsigned int    FT_UInt32;
    
    #elif FT_SIZEOF_LONG == 4
    
      typedef signed long     FT_Int32;
      typedef unsigned long   FT_UInt32;
    
    #else
    #error "no 32bit type found -- please check your configuration files"
    #endif
    
      /* look up an integer type that is at least 32 bits */
    #if FT_SIZEOF_INT >= 4
    
      typedef int            FT_Fast;
      typedef unsigned int   FT_UFast;
    
    #elif FT_SIZEOF_LONG >= 4
    
      typedef long           FT_Fast;
      typedef unsigned long  FT_UFast;
    
    #endif
    
    
      /* determine whether we have a 64-bit int type for platforms without */
      /* Autoconf                                                          */
    #if FT_SIZEOF_LONG == 8
    
      /* FT_LONG64 must be defined if a 64-bit type is available */
    #define FT_LONG64
    #define FT_INT64  long
    
    #elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
    
      /* this compiler provides the __int64 type */
    #define FT_LONG64
    #define FT_INT64  __int64
    
    #elif defined( __BORLANDC__ )  /* Borland C++ */
    
      /* XXXX: We should probably check the value of __BORLANDC__ in order */
      /*       to test the compiler version.                               */
    
      /* this compiler provides the __int64 type */
    #define FT_LONG64
    #define FT_INT64  __int64
    
    #elif defined( __WATCOMC__ )   /* Watcom C++ */
    
      /* Watcom doesn't provide 64-bit data types */
    
    #elif defined( __MWERKS__ )    /* Metrowerks CodeWarrior */
    
    #define FT_LONG64
    #define FT_INT64  long long int
    
    #elif defined( __GNUC__ )
    
      /* GCC provides the `long long' type */
    #define FT_LONG64
    #define FT_INT64  long long int
    
    #endif /* FT_SIZEOF_LONG == 8 */
    
    
    #define FT_BEGIN_STMNT  do {
    #define FT_END_STMNT    } while ( 0 )
    #define FT_DUMMY_STMNT  FT_BEGIN_STMNT FT_END_STMNT
    
    
      /*************************************************************************/
      /*                                                                       */
      /* A 64-bit data type will create compilation problems if you compile    */
      /* in strict ANSI mode.  To avoid them, we disable their use if          */
      /* __STDC__ is defined.  You can however ignore this rule by             */
      /* defining the FT_CONFIG_OPTION_FORCE_INT64 configuration macro.        */
      /*                                                                       */
    #if defined( FT_LONG64 ) && !defined( FT_CONFIG_OPTION_FORCE_INT64 )
    
    #ifdef __STDC__
    
      /* undefine the 64-bit macros in strict ANSI compilation mode */
    #undef FT_LONG64
    #undef FT_INT64
    
    #endif /* __STDC__ */
    
    #endif /* FT_LONG64 && !FT_CONFIG_OPTION_FORCE_INT64 */
    
    
    #ifdef FT_MAKE_OPTION_SINGLE_OBJECT
    
    #define FT_LOCAL( x )      static  x
    #define FT_LOCAL_DEF( x )  static  x
    
    #else
    
    #ifdef __cplusplus
    #define FT_LOCAL( x )      extern "C"  x
    #define FT_LOCAL_DEF( x )  extern "C"  x
    #else
    #define FT_LOCAL( x )      extern  x
    #define FT_LOCAL_DEF( x )  x
    #endif
    
    #endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
    
    
    #ifndef FT_BASE
    
    #ifdef __cplusplus
    #define FT_BASE( x )  extern "C"  x
    #else
    #define FT_BASE( x )  extern  x
    #endif
    
    #endif /* !FT_BASE */
    
    
    #ifndef FT_BASE_DEF
    
    #ifdef __cplusplus
    #define FT_BASE_DEF( x )  extern "C"  x
    #else
    #define FT_BASE_DEF( x )  extern  x
    #endif
    
    #endif /* !FT_BASE_DEF */
    
    
    #ifndef FT_EXPORT
    
    #ifdef __cplusplus
    #define FT_EXPORT( x )  extern "C"  x
    #else
    #define FT_EXPORT( x )  extern  x
    #endif
    
    #endif /* !FT_EXPORT */
    
    
    #ifndef FT_EXPORT_DEF
    
    #ifdef __cplusplus
    #define FT_EXPORT_DEF( x )  extern "C"  x
    #else
    #define FT_EXPORT_DEF( x )  extern  x
    #endif
    
    #endif /* !FT_EXPORT_DEF */
    
    
    #ifndef FT_EXPORT_VAR
    
    #ifdef __cplusplus
    #define FT_EXPORT_VAR( x )  extern "C"  x
    #else
    #define FT_EXPORT_VAR( x )  extern  x
    #endif
    
    #endif /* !FT_EXPORT_VAR */
    
      /* The following macros are needed to compile the library with a   */
      /* C++ compiler and with 16bit compilers.                          */
      /*                                                                 */
    
      /* This is special.  Within C++, you must specify `extern "C"' for */
      /* functions which are used via function pointers, and you also    */
      /* must do that for structures which contain function pointers to  */
      /* assure C linkage -- it's not possible to have (local) anonymous */
      /* functions which are accessed by (global) function pointers.     */
      /*                                                                 */
      /*                                                                 */
      /* FT_CALLBACK_DEF is used to _define_ a callback function.        */
      /*                                                                 */
      /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */
      /* contains pointers to callback functions.                        */
      /*                                                                 */
      /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable   */
      /* that contains pointers to callback functions.                   */
      /*                                                                 */
      /*                                                                 */
      /* Some 16bit compilers have to redefine these macros to insert    */
      /* the infamous `_cdecl' or `__fastcall' declarations.             */
      /*                                                                 */
    #ifndef FT_CALLBACK_DEF
    #ifdef __cplusplus
    #define FT_CALLBACK_DEF( x )  extern "C"  x
    #else
    #define FT_CALLBACK_DEF( x )  static  x
    #endif
    #endif /* FT_CALLBACK_DEF */
    
    #ifndef FT_CALLBACK_TABLE
    #ifdef __cplusplus
    #define FT_CALLBACK_TABLE      extern "C"
    #define FT_CALLBACK_TABLE_DEF  extern "C"
    #else
    #define FT_CALLBACK_TABLE      extern
    #define FT_CALLBACK_TABLE_DEF  /* nothing */
    #endif
    #endif /* FT_CALLBACK_TABLE */
    
    
    FT_END_HEADER
    
    
    #endif /* __FTCONFIG_H__ */
    
    
    /* END */