fx_system.h

Go to the documentation of this file.

//<<<+++OPENSOURCE
//<<<+++OPENSOURCE_LICENSE
//<<<+++OPENSOURCE_BEGIN LIC==FOXIT||LIC==GOOGLE

/*
 * @brief System dependant service routines.
 * All system-specific function and non-standard C/C++ routines go here
 *
 * FPDFAPI PREDEFINED MACROES
 *
 * FPDFAPI makes use of a number of predefined macroes to support all kind of platforms
 * with a single set of codes. In most of times, application developers can ignore those
 * macroes because they are properly defined according to system or compiler environment
 * settings. However, sometimes, especially for cross platform development, FPDFAPI might
 * take incorrect settings of the host platform, rather then the target platform. In such
 * case, the application developers should manually set necessary macroes in their project
 * settings.
 *
 *
 * Currently the following macroes are defined:
 * - #_FX_OS_        The target operating system
 * - #_FX_COMPILER_      The compiler
 * - #_FX_CPU_        The CPU
 * - #_FX_ENDIAN_      Little endian or big endian
 *
 * #_FX_OS_ can be one of the followings:
 * - #_FX_WIN32_DESKTOP_  Windows desktop OS (from Windows 95)
 * - #_FX_WIN32_MOBILE_    Windows Mobile OS (from Windows CE 4.0)
 * - #_FX_WIN64_      Windows 64 bit
 * - #_FX_LINUX_DESKTOP_  Linux Desktop OS
 * - #_FX_LINUX_EMBEDDED_  Embedded Linux OS
 * - #_FX_SYMBIAN_      Symbian OS (from 7.0)
 * - #_FX_MACOSX_      MAC OS X
 * - #_FX_EMBEDDED_      Embedded OS
 * - #_FX_SOLARIS_      Solaris 8 or later
 * - #_FX_PALMOS_      PalmOS (5.0 or later)
 * - #_FX_NETBSD_      NetBSD
 * - #_FX_ANDROID_      Android
 * - #_FX_VXWORKS_      VxWorks
 *
 * #_FX_COMPILER_ can be one of the following:
 * - #_FX_VC6_      Microsoft Visual C++ 6.0
 * - #_FX_VC7_      Microsoft Visual Studio.Net 2003
 * - #_FX_VC8_      Microsoft Visual Studio.Net 2005
 * - #_FX_GCC_      GNU C++ Compiler
 * - #_FX_ADS_      ADS 1.2 Compiler
 * - #_FX_RVCT_      RVCT 2.1 Compiler
 * - #_FX_IARCC_    IAR C/C++ Compiler
 * - #_FX_NOKIA_X86_  Nokia X86 Compiler
 * - #_FX_METROWERKS_  Metrowerks C/C++ Compiler (with MSL)
 * - #_FX_PACC_      Protein C/C++ Compiler (used by PalmOS)
 * - #_FX_MIPS_SDE_    MIPS SDE
 *
 * #_FX_CPU_ can be one of the following:
 * - #_FX_X86_      32-bit x86 CPU
 * - #_FX_X64_      64-bit x86 CPU
 * - #_FX_POWERPC_    Power PC
 * - #_FX_ARM_      ARM
 * - #_FX_SPARC_    Sparc
 * - #_FX_MIPS_      MIPS
 * - #_FX_ARM64_        64-bit ARM
 *
 * #_FX_ENDIAN_ can be one of the following:
 * - #_FX_BIG_ENDIAN_
 * - #_FX_LITTLE_ENDIAN_
 *
 * #_FX_WORDSIZE_ can be one of the following:
 * - #_FX_W32_      32-bit instruct
 * - #_FX_W64_      64-bit instruct
 */

//<<<+++OPENSOURCE_MUST_BEGIN
#ifndef _FX_SYSTEM_H_
#define _FX_SYSTEM_H_
//<<<+++OPENSOURCE_MUST_END

#ifdef _WIN32_WCE
    #ifndef _SIZE_T_DEFINED
    #define _SIZE_T_DEFINED
    #endif  //_SIZE_T_DEFINED
#endif


#define _FX_WIN32_DESKTOP_    1
  //<<<+++OPENSOURCE_BEGIN LIC==FOXIT
  #define _FX_WIN32_MOBILE_    2

  #define _FX_WIN64_        3
  //<<<+++OPENSOURCE_END

#define _FX_LINUX_DESKTOP_    4

  #define _FX_LINUX_EMBEDDED_    5

  #define _FX_SYMBIAN_      6

#define _FX_MACOSX_        7

  #define _FX_EMBEDDED_      8

  #define _FX_SOLARIS_      9

  #define _FX_PALMOS_        10

  #define _FX_NETBSD_        11
  //<<<+++OPENSOURCE_END

#define _FX_ANDROID_      12

  #define _FX_VXWORKS_      13

  #define _FX_MTK_        14

  #define _FX_IOS_                15

#define _FXM_PLATFORM_WINDOWS_    1

#define _FXM_PLATFORM_LINUX_    2

#define _FXM_PLATFORM_APPLE_    3

#define _FXM_PLATFORM_ANDROID_    4

#ifdef __pnacl__
#define _CHROME_PNACL_
#endif

#if defined(_FXM_PLATFORM_LINUX_JS_) || defined(_CHROME_PNACL_)
  #define _FX_OS_ _FX_LINUX_DESKTOP_
  #define _FXM_PLATFORM_ _FXM_PLATFORM_LINUX_
#endif

/* OS */

#ifndef _FX_OS_
        #if   defined(__SYMBIAN32__) || defined(__symbian__)
                #define _FX_OS_ _FX_SYMBIAN_
        #elif defined(_WIN32_WCE)
                #define _FX_OS_ _FX_WIN32_MOBILE_
                #define _FXM_PLATFORM_ _FXM_PLATFORM_WINDOWS_
                #if defined (_WIN32_WCE) && (_WIN32_WCE == 0x600)
                        #define UNSUPPORT_CPP0X
                #endif
        #elif defined(__linux__) || defined(__native_client__)
                #if ((defined(__arm__) || defined(__aarch64__)) && defined(__ARM_EABI__)) && (!defined(OS_CHROMEOS))
                        #define _FX_OS_ _FX_LINUX_EMBEDDED_
                #else
                        #define _FX_OS_ _FX_LINUX_DESKTOP_
                #endif
                #define _FXM_PLATFORM_ _FXM_PLATFORM_LINUX_
        #elif defined(__NetBSD__)
                #define _FX_OS_ _FX_NETBSD_
        #elif defined(_WIN64)
                #define _FX_OS_ _FX_WIN64_
                #define _FXM_PLATFORM_ _FXM_PLATFORM_WINDOWS_
        #elif defined(_WIN32)
                #define _FX_OS_ _FX_WIN32_DESKTOP_
                #define _FXM_PLATFORM_ _FXM_PLATFORM_WINDOWS_
        #elif defined(__sparc__)
                #define _FX_OS_ _FX_SOLARIS_
                #define _FXM_PLATFORM_ _FXM_PLATFORM_LINUX_
        #elif defined(__ARMCC_VERSION) || defined(__ICCARM__) || defined(__TMS470__)
                #define _FX_OS_ _FX_EMBEDDED_
        #elif defined(__APPLE__)
        #include "TargetConditionals.h"
        #if (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) || (defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR == 1)
            #define _FX_OS_ _FX_IOS_
        #else
            #define _FX_OS_ _FX_MACOSX_
        #endif
    #define _FXM_PLATFORM_ _FXM_PLATFORM_APPLE_
  #elif defined(__ARM_EABI__)
    #define _FX_OS_ _FX_EMBEDDED_
  #endif
#else
    #if _FX_OS_ == _FX_ANDROID_
        #ifndef _FXM_PLATFORM_
            #define _FXM_PLATFORM_ _FXM_PLATFORM_ANDROID_
        #endif
    #elif (_FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_ || _FX_OS_ == _FX_WIN32_DESKTOP_)
        #ifndef _FXM_PLATFORM_
            #define _FXM_PLATFORM_ _FXM_PLATFORM_WINDOWS_
        #endif
    #elif (_FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_MACOSX_)
        #ifndef _FXM_PLATFORM_
            #define _FXM_PLATFORM_ _FXM_PLATFORM_APPLE_
        #endif
    #elif _FX_OS_ == _FX_SOLARIS_ || _FX_OS_ == _FX_LINUX_EMBEDDED_ || _FX_OS_ == _FX_LINUX_DESKTOP_
        #ifndef _FXM_PLATFORM_
            #define _FXM_PLATFORM_ _FXM_PLATFORM_LINUX_
        #endif
    #endif
#endif //_FX_OS_

#if !defined(_FX_OS_) || _FX_OS_ == 0
  #error Sorry, can not figure out what OS you are targeting to. Please specify _FX_OS_ macro.
#endif

//<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
#if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)

  #define _CRT_SECURE_NO_WARNINGS
  #if defined(_MSC_VER) && _MSC_VER < 1300
    #define _WIN32_WINNT 0x400
  #endif
  #if defined(_MSC_VER) && _MSC_VER < 1600
  #define UNSUPPORT_CPP0X
  #endif
  #ifndef NOMINMAX
    #define NOMINMAX
  #endif
  #include <windows.h>

  #ifdef WINAPI_FAMILY
    #if (0x00000001 == WINAPI_PARTITION_DESKTOP) && (0x00000002 == WINAPI_PARTITION_APP) //Macros in Windows Kit/8
    #define _FX_WIN8_
    #else //Macros in Windows Kit/8.1
    #define _FX_WIN81_
    #endif //(0x00000001 == WINAPI_PARTITION_DESKTOP) && (0x00000002 == WINAPI_PARTITION_APP)

    #ifdef _FX_WIN8_
      #if /*defined(WINAPI_FAMILY) && */((WINAPI_FAMILY&WINAPI_PARTITION_APP) == WINAPI_PARTITION_APP)

      #define _FX_WINAPI_PARTITION_APP_
      #endif
      #if defined(WINAPI_FAMILY) && ((WINAPI_FAMILY&WINAPI_PARTITION_DESKTOP) == WINAPI_PARTITION_DESKTOP)

      #define _FX_WINAPI_PARTITION_DESKTOP_
      #endif
    #endif //_FX_WIN8_

    #ifdef _FX_WIN81_

      #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP)

      #define _FX_WINAPI_PARTITION_APP_
      #endif

      #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP) && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP)

      #define _FX_WINAPI_PARTITION_PHONE_APP_
      #endif

      #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

      #define _FX_WINAPI_PARTITION_DESKTOP_
      #endif
    #endif //_FX_WIN81_
  #else // !defined(WINAPI_FAMILY)
  #ifndef _WIN32_WCE
    #define _FX_WINAPI_PARTITION_DESKTOP_
  #endif
  #endif //WINAPI_FAMILY
#endif //(_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)
//<<<+++OPENSOURCE_MUST_END


#define _FX_VC6_    1

#define _FX_VC7_    2

#define _FX_VC8_    3

#define _FX_GCC_    4

#define _FX_ADS_    5

#define _FX_RVCT_    6

#define _FX_IARCC_    7

#define _FX_NOKIA_X86_  8

#define _FX_METROWERKS_  9

#define _FX_PACC_    10

#define _FX_TMS470_    11

#define _FX_MIPS_SDE_  12

/* Compiler */
#ifndef _FX_COMPILER_
  #ifdef _MSC_VER
    #if _MSC_VER >= 1400
      #define _FX_COMPILER_ _FX_VC8_
    #elif _MSC_VER >= 1300
      #define _FX_COMPILER_ _FX_VC7_
    #else

      #define _FX_COMPILER_ _FX_VC6_
    #endif
  #elif defined(__GNUC__)
    #define _FX_COMPILER_ _FX_GCC_
  #elif defined(__ARMCC_VERSION)
    #if __ARMCC_VERSION < 200000
      #define _FX_COMPILER_ _FX_ADS_
    #else
      #define _FX_COMPILER_ _FX_RVCT_
    #endif
  #elif defined(__ICCARM__)
    #define _FX_COMPILER_ _FX_IARCC_
  #elif defined(_PACC_VER)
    #define _FX_COMPILER_ _FX_PACC_
  #elif defined(__TMS470__)
    #define _FX_COMPILER_ _FX_TMS470_
  #endif
#endif  /* !_FX_COMPILER_ */
#if !defined(_FX_COMPILER_) || _FX_COMPILER_ == 0
  #error Sorry, can not figure out what compiler you are using. Please specify _FX_COMPILER_ macro.
#endif
//<<<+++OPENSOURCE_MUST_END


#define _FX_X86_    1

#define _FX_ARM_    2

#define _FX_POWERPC_  3

#define _FX_SPARC_    4

#define _FX_IA64_    5

#define _FX_MIPS_    6

#define _FX_X64_    7

#define _FX_ARM64_      8

#define _FX_MIPS64_           9

#define _FX_LOONGARCH64_        10

#define _FX_SW64_                       11

#if defined(_FXM_PLATFORM_LINUX_JS_)
#if defined(__wasm64__)
#define _FX_CPU_ _FX_X64_
#else
#define _FX_CPU_ _FX_X86_
#endif  // defined(__wasm64__)
#endif  // defined(_FXM_PLATFORM_LINUX_JS_)

#if defined(_CHROME_PNACL_)
  #define _FX_CPU_ _FX_X86_
#endif
/* CPU */
#ifndef _FX_CPU_
        #if defined(__arm__) || defined(ARM) || defined(_ARM_) || defined(__ARMCC_VERSION) || defined(__ICCARM__) || defined(__arm) || defined(arm9) || defined(_M_ARM)
                #define _FX_CPU_ _FX_ARM_
    #elif defined(__arm64) || defined(__arm64__) || defined(__aarch64__) || defined(_ARM64_) || defined(_M_ARM64)
        #define _FX_CPU_ _FX_ARM64_
  #elif defined(_M_IX86) || defined(__i386__)

    #define _FX_CPU_ _FX_X86_
  #elif defined(_M_X64) || defined(__x86_64__)
    #define _FX_CPU_ _FX_X64_
  #elif defined(_M_IA64)
    #define _FX_CPU_ _FX_IA64_
  #elif defined(__POWERPC__)
    #define _FX_CPU_ _FX_POWERPC_
  #elif defined(__sparc__)
    #define _FX_CPU_ _FX_SPARC_
  #elif defined(__mips64)
    #define _FX_CPU_ _FX_MIPS64_
  #elif defined(__loongarch64)
    #define _FX_CPU_ _FX_LOONGARCH64_
        #elif defined(__sw_64__) || defined(__sw_64)
                #define _FX_CPU_ _FX_SW64_
  #elif defined(MIPS) || defined(_MIPS_) || defined(__mips)
    #define _FX_CPU_ _FX_MIPS_
  #endif
#endif
#if !defined(_FX_CPU_) || _FX_CPU_ == 0
  #error Sorry, can not figure out what CPU you are targeting to. Please specify _FX_CPU_ macro.
#endif
//<<<+++OPENSOURCE_MUST_END

#ifdef _MSC_VER
  #if _MSC_VER >= 1600
    #define _FX_EMBEDFONT_PRINT_
  #endif
#endif


//<<<+++OPENSOURCE_MUST_BEGIN
#define _FX_W32_    1

#define _FX_W64_    2

/* Word size or instruct length */
#ifndef _FX_WORDSIZE_
#if defined(_WIN64) || defined(__arm64) || defined(__arm64__) || defined(_M_AMD64) ||       \
    defined(_M_X64) || defined(_M_IA64) || defined(__powerpc64__) || defined(__x86_64__) || \
    __WORDSIZE == 64 || defined(__LP64__) || defined(__mips64) || defined(__loongarch64)
#define _FX_WORDSIZE_   _FX_W64_
#else
#define _FX_WORDSIZE_   _FX_W32_
#endif
#endif
//<<<+++OPENSOURCE_MUST_END


#define _FX_BIG_ENDIAN_    1

#define _FX_LITTLE_ENDIAN_  2

/* Byte Order */
#ifndef _FX_ENDIAN_
  #if _FX_CPU_ == _FX_POWERPC_ || _FX_CPU_ == _FX_SPARC_
    #define _FX_ENDIAN_ _FX_BIG_ENDIAN_
  #else

    #define _FX_ENDIAN_ _FX_LITTLE_ENDIAN_
  #endif
#endif

/* Include basic headers */
#include <stddef.h>
#include <stdarg.h>
#include <setjmp.h>
#include <float.h>

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #ifndef _FX_NO_ANSIC_
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <assert.h>
    #if _FX_OS_ != _FX_VXWORKS_ && ((_FX_COMPILER_ == _FX_GCC_ && _FX_OS_ != _FX_SYMBIAN_) || _FX_COMPILER_ == _FX_NOKIA_X86_ || _FX_COMPILER_ == _FX_METROWERKS_ || _FX_COMPILER_ == _FX_IARCC_)
      #include <wchar.h>
    #endif
  #endif
  //<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
  #include <libkern/OSAtomic.h>
  #if _FX_OS_ == _FX_MACOSX_
    #include <Carbon/Carbon.h>
  #elif _FX_OS_ == _FX_IOS_
     #include <CoreText/CoreText.h>
     #include <CoreGraphics/CoreGraphics.h>
  #endif
#endif
//<<<+++OPENSOURCE_MUST_END

#ifdef _UNICODE
  #define GetObject GetObjectW
  #define GetModuleFileName GetModuleFileNameW
  #define GetFullPathName GetFullPathNameW
#else

  #define GetObject GetObjectA

  #define GetModuleFileName GetModuleFileNameA

  #define GetFullPathName GetFullPathNameA
#endif

#if ( _FX_OS_ == _FX_IOS_ && (_FX_CPU_ == _FX_ARM_ || _FX_CPU_ == _FX_ARM64_)) || (_FX_OS_ == _FX_ANDROID_) || (_FX_OS_ == _FX_WIN32_MOBILE_)
  #ifndef _FXCORE_LIMITED_MEMORY_
    #define _FXCORE_LIMITED_MEMORY_
  #endif
  #ifndef _FXCORE_LIMITED_CPU_
    #define _FXCORE_LIMITED_CPU_
  #endif
#endif

#if _FX_COMPILER_ == _FX_ADS_ || _FX_COMPILER_ == _FX_RVCT_  || _FX_COMPILER_ == _FX_TMS470_ || _FX_OS_ == _FX_ANDROID_
  //#define _FX_NO_EXCEPTION_    //Removed by Malcolm J. Xue, Sep. 9th, 2010, should be defined outside
  #define _FX_NO_NAMESPACE_
#endif


#define _FX_DEFAULT_TARGET_    0

#define _FX_BREW_        1

//<<<+++OPENSOURCE_MUST_END

#if (((_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_) && (defined(_FX_WINAPI_PARTITION_DESKTOP_) || defined(_FX_WINAPI_PARTITION_APP_))) || _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_)
#ifndef _FX_NO_SIMD_
#if !defined(_FXM_PLATFORM_LINUX_JS_) && !defined(_CHROME_PNACL_) && (_FX_CPU_ != _FX_ARM_) && \
    (_FX_CPU_ != _FX_ARM64_) && (_FX_CPU_ != _FX_MIPS_) && (_FX_CPU_ != _FX_MIPS64_) && \
    (_FX_CPU_ != _FX_LOONGARCH64_) && (_FX_CPU_ != _FX_SW64_)
#define _FXM_SIMD_
#endif
#endif
#endif
#if _FX_OS_ != _FX_MACOSX_
  //#define  _FXM_OPENMP_
#endif

#ifndef _FX_NO_OPENSSL_
  #define _FX_NO_OPENSSL_
#endif

#if (((_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_) && defined(_FX_WINAPI_PARTITION_DESKTOP_)) || _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_)
#ifndef _FX_NO_JPEG_TURBO_
  #if !defined(_CHROME_PNACL_)
    #define _FX_JPEG_TURBO_
  #endif
#endif
#ifndef _FX_NO_OPENSSL_
   #define _FXM_OPENSSL_
#endif
  #define _FX_LARGEFILE_SUPPORT_
#ifndef _FX_NO_SIMD_
  #define WITH_SIMD
#endif
  #define _FPDF_STREAM_RENDER_
#ifndef _FX_ENABLE_OVERPRINT_
  #define _FX_ENABLE_OVERPRINT_
#endif
#endif

#if _FX_OS_ == _FX_LINUX_EMBEDDED_
#ifndef _FX_ENABLE_OVERPRINT_
  #define _FX_ENABLE_OVERPRINT_
#endif
#endif

#ifdef _FX_WINAPI_PARTITION_APP_
#define _FPDF_STREAM_RENDER_
#endif
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifdef __cplusplus
extern "C" {
#endif
//<<<+++OPENSOURCE_MUST_END

typedef void*          FX_LPVOID;
typedef void const*        FX_LPCVOID;
  typedef void*          FX_POSITION;

typedef signed char        FX_INT8;
typedef unsigned char      FX_UINT8;
typedef unsigned char      FX_BYTE;
typedef unsigned char*      FX_LPBYTE;
typedef unsigned char const*  FX_LPCBYTE;
typedef short          FX_INT16;
typedef unsigned short      FX_UINT16;
typedef short          FX_SHORT;
typedef unsigned short      FX_WORD;
typedef unsigned short*      FX_LPWORD;
typedef unsigned short const*  FX_LPCWORD;
typedef int            FX_INT32;
typedef float          FX_FLOAT;
#ifdef __cplusplus

typedef bool          FX_BOOL;
#else

typedef int            FX_BOOL;
#endif

typedef int            FX_ERR;
#define FX_SUCCEEDED(Status)  ((FX_ERR)(Status) >= 0)

#define FX_FAILED(Status)    ((FX_ERR)(Status) < 0)

typedef char          FX_CHAR;
typedef char*          FX_LPSTR;
typedef char const*        FX_LPCSTR;

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #if !defined(_MSC_VER) && (_FX_CPU_ == _FX_X64_ || _FX_CPU_ == _FX_IA64_ || _FX_CPU_ == _FX_ARM64_ || _FX_CPU_ == _FX_MIPS64_ || _FX_CPU_ == _FX_LOONGARCH64_ || _FX_CPU_ == _FX_SW64_)

    typedef unsigned int      FX_DWORD;
    typedef unsigned int*      FX_LPDWORD;
  #else

    typedef unsigned long      FX_DWORD;
    typedef unsigned long*      FX_LPDWORD;
  #endif

  typedef wchar_t          FX_WCHAR;
  typedef wchar_t*        FX_LPWSTR;
  typedef wchar_t const*      FX_LPCWSTR;

  #ifdef _MSC_VER

    typedef __int64        FX_INT64;
    typedef unsigned __int64  FX_UINT64;
  #else
    typedef long long int    FX_INT64;
    typedef unsigned long long  FX_UINT64;
  #endif

  #if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)

    typedef INT_PTR FX_INTPTR;
    typedef UINT_PTR FX_UINTPTR;
  #else
    #if (_FX_CPU_ == _FX_X64_ || _FX_CPU_ == _FX_IA64_ || _FX_CPU_ == _FX_ARM64_ || _FX_CPU_ == _FX_MIPS64_ || _FX_CPU_ == _FX_LOONGARCH64_|| _FX_CPU_ == _FX_SW64_)
      typedef FX_INT64      FX_INTPTR;
      typedef FX_UINT64      FX_UINTPTR;
    #else
      typedef int          FX_INTPTR;
      typedef unsigned int    FX_UINTPTR;
    #endif
  #endif
  //<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
typedef FX_DWORD        FX_UINT32;
typedef FX_UINT64        FX_QWORD;

#define FX_DEFINEHANDLE(name)  typedef struct _##name {FX_LPVOID pData;} * name;

#if defined(DEBUG) && !defined(_DEBUG)
  #define _DEBUG
#endif

#ifndef __cplusplus
#ifndef TRUE

  #define TRUE  1
#endif

#ifndef FALSE

  #define FALSE  0
#endif
#endif

#ifndef NULL

  #define NULL  0
#endif
//<<<+++OPENSOURCE_MUST_END

/* Assertion */

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #if !defined(_FX_NO_ANSIC_)

    #define FXSYS_assert assert
  #else
    void  FXSYS_assert(int condition);
  #endif
  //<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifndef ASSERT
  #ifdef _DEBUG
    #define ASSERT FXSYS_assert
  #else

    #define ASSERT(a)
  #endif
#endif

#define FX_MAX(a, b) (((a) > (b)) ? (a) : (b))

#define FX_MIN(a, b) (((a) < (b)) ? (a) : (b))

#define FX_PI  3.1415926535897932384626433832795f

#if _FX_WORDSIZE_ == _FX_W64_ && _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
  #define _FX_CRT_MALLOC_LIMIT_  0x7fffffffffffffffL
#else
  #define _FX_CRT_MALLOC_LIMIT_  0x7fffffffL
#endif

//<<<+++OPENSOURCE_MUST_END


  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #if !defined(_FX_NO_ANSIC_)

    #define FXSYS_sprintf sprintf

    #ifdef _WIN32
      #define FXSYS_snprintf _snprintf
      #define FXSYS_vsnprintf  _vsnprintf
    #else
      #define FXSYS_snprintf snprintf
      #define FXSYS_vsnprintf  vsnprintf
    #endif

    #define FXSYS_vsprintf vsprintf

    #define FXSYS_strchr strchr

    #define FXSYS_strlen strlen

    #define FXSYS_strncmp strncmp

    #define FXSYS_strcmp strcmp

    #define FXSYS_strcpy strcpy

    #define FXSYS_strncpy strncpy

    #define FXSYS_strstr strstr
  #else
    int    FXSYS_sprintf(char* buffer, const char* format, ...);
    int    FXSYS_vsprintf(char *buffer, const char *format, va_list args);
    char*  FXSYS_strchr(const char* str, int ch);
    long  FXSYS_strlen(const char* str);
    int    FXSYS_strncmp(const char* str1, const char* str2, size_t len);
    int    FXSYS_strcmp(const char* str1, const char* str2);
    char*  FXSYS_strcpy(char* dest, const char* src);
    char*  FXSYS_strncpy(char* dest, const char* src, size_t len);
    char*  FXSYS_strstr(const char *string, const char *strFind);
  #endif
  //<<<+++OPENSOURCE_MUST_END

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #if !defined(_FX_NO_ANSIC_) && !defined(__EMSCRIPTEN__)

    #define FXSYS_FILE FILE

    #define FXSYS_fopen fopen

    #define FXSYS_fclose fclose

    #define FXSYS_SEEK_END SEEK_END

    #define FXSYS_SEEK_SET SEEK_SET

    #define FXSYS_fseek fseek

    #define FXSYS_ftell ftell

    #define FXSYS_fread fread

    #define FXSYS_fwrite fwrite

    #define FXSYS_fprintf fprintf

    #define FXSYS_fflush fflush
  #else
    #define FXSYS_FILE void
    FXSYS_FILE*  FXSYS_fopen(const char* filename, const char* mode);
    int    FXSYS_fclose(FXSYS_FILE*);
    #define  FXSYS_SEEK_END  2
    #define  FXSYS_SEEK_SET  0
    int    FXSYS_fseek(FXSYS_FILE*, long, int);
    long  FXSYS_ftell(FXSYS_FILE*);
    size_t  FXSYS_fread(void*, size_t, size_t, FXSYS_FILE*);
    long  FXSYS_fwrite(const void*, long, long, FXSYS_FILE*);
    int    FXSYS_fprintf(FXSYS_FILE*, const char*, ...);
    int    FXSYS_fflush(FXSYS_FILE*);
  #endif

  // For now, we provide wide-string file name support for Windows only
  #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_

    #ifdef _NATIVE_WCHAR_T_DEFINED
      #define FXSYS_wfopen(f, m) _wfopen((const wchar_t*)(f), (const wchar_t*)(m))
    #else
      #define FXSYS_wfopen _wfopen
    #endif
  #else
    FXSYS_FILE* FXSYS_wfopen(FX_LPCWSTR filename, FX_LPCWSTR mode);
  #endif


  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  /* Basic wide string operations, not available in ADS/RVCT/PACC/Android/MIPS_SDE */
  #if _FX_OS_ != _FX_VXWORKS_ && _FX_OS_ != _FX_ANDROID_ && !defined(_FX_NO_ANSIC_) && _FX_COMPILER_ != _FX_ADS_ && _FX_COMPILER_ != _FX_RVCT_ && _FX_COMPILER_ != _FX_PACC_ && _FX_COMPILER_ != _FX_TMS470_ && _FX_COMPILER_ != _FX_MIPS_SDE_
    #ifdef _NATIVE_WCHAR_T_DEFINED
      #define FXSYS_wcslen(str) wcslen((wchar_t*)(str))
      #define FXSYS_wcscmp(str1, str2) wcscmp((wchar_t*)(str1), (wchar_t*)(str2))
    #else

      #define FXSYS_wcslen wcslen

      #define FXSYS_wcscmp wcscmp
    #endif
  #else
    size_t  FXSYS_wcslen(const wchar_t*);
    int    FXSYS_wcscmp(const wchar_t*, const wchar_t*);
  #endif

  /* Some other wide string functions, not available in ADS/RVCT/GCCE/PACC/Android/MIPS_SDE */
  #if _FX_OS_ != _FX_VXWORKS_ && _FX_OS_ != _FX_ANDROID_ && !defined(_FX_NO_ANSIC_) && _FX_COMPILER_ != _FX_ADS_ && _FX_COMPILER_ != _FX_RVCT_ && !(_FX_COMPILER_ == _FX_GCC_ && _FX_OS_ == _FX_SYMBIAN_) && _FX_COMPILER_ != _FX_PACC_ && _FX_COMPILER_ != _FX_TMS470_ && _FX_COMPILER_ != _FX_MIPS_SDE_
    #ifdef _NATIVE_WCHAR_T_DEFINED
      #define FXSYS_wcschr(str, ch) (FX_LPCWSTR)wcschr((wchar_t*)(str), ch)
      #define FXSYS_wcsstr(str1, str2) (FX_LPCWSTR)wcsstr((wchar_t*)(str1), (wchar_t*)(str2))
      #define FXSYS_wcsncmp(str1, str2, n) wcsncmp((wchar_t*)(str1), (wchar_t*)(str2), n)
    #else

      #define FXSYS_wcschr wcschr

      #define FXSYS_wcsstr wcsstr

      #define FXSYS_wcsncmp wcsncmp
    #endif

    #define FXSYS_vswprintf vswprintf
  #else
    wchar_t*  FXSYS_wcschr(const wchar_t*, wchar_t);
    wchar_t*  FXSYS_wcsstr(const wchar_t*, const wchar_t*);
    int    FXSYS_wcsncmp(const wchar_t*, const wchar_t*, size_t);
    #if _FX_OS_ != _FX_ANDROID_
      int    FXSYS_vswprintf(wchar_t*, const wchar_t*, va_list);
    #else
      #define FXSYS_vswprintf vswprintf
    #endif
  #endif

  #if !defined(_FX_NO_ANSIC_) && _FX_COMPILER_ != _FX_TMS470_

    #define FXSYS_mbstowcs mbstowcs

    #define FXSYS_wcstombs wcstombs
  #else
    size_t  FXSYS_mbstowcs(wchar_t *dest, const char *src, size_t n);
    size_t  FXSYS_wcstombs(char *dest, const wchar_t *src, size_t n);
  #endif
  //<<<+++OPENSOURCE_MUST_END

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT

  #if !defined(_FX_NO_ANSIC_)

    #define FXSYS_memcmp memcmp

    #define FXSYS_memcpy memcpy

    #define FXSYS_memmove memmove

    #define FXSYS_memset memset

    #define FXSYS_memchr memchr
  #else
    int    FXSYS_memcmp(const void*, const void*, size_t);
    void*  FXSYS_memcpy(void*, const void*, size_t);
    void*  FXSYS_memmove(void*, const void*, size_t);
    void*  FXSYS_memset(void*, int, size_t);
    void*  FXSYS_memchr(const void*, int, size_t);
  #endif

  /* Others */
  #if !defined(_FX_NO_ANSIC_)

    #define FXSYS_qsort qsort
  #else
    void  FXSYS_qsort(void*, unsigned, unsigned, int (*)(const void*, const void*));
  #endif

  #if _FX_OS_ != _FX_WIN32_MOBILE_ && !defined(_FX_NO_ANSIC_) && _FX_OS_ != _FX_SYMBIAN_

    #define FXSYS_bsearch bsearch
  #else
    /* WinCE doesn't support bsearch. The bsearch function comes with Symbian also has crash problem. */
    void *  FXSYS_bsearch(const void *key, const void *base, size_t num, size_t width, int (*compare)(const void *, const void *));
  #endif

  #if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)
    /* On Windows platform, we can replace more system calls */

    #define FXSYS_itoa _itoa

    #define FXSYS_strlwr _strlwr

    #define FXSYS_strupr _strupr

    #define FXSYS_stricmp _stricmp

    #ifdef _NATIVE_WCHAR_T_DEFINED
      #define FXSYS_wcsicmp(str1, str2) _wcsicmp((wchar_t*)(str1), (wchar_t*)(str2))
      #define FXSYS_WideCharToMultiByte(p1, p2, p3, p4, p5, p6, p7, p8) WideCharToMultiByte(p1, p2, (const wchar_t*)(p3), p4, p5, p6, p7, p8)
      #define FXSYS_MultiByteToWideChar(p1, p2, p3, p4, p5, p6) MultiByteToWideChar(p1, p2, p3, p4, (wchar_t*)(p5), p6)
      #define FXSYS_wcslwr(str) _wcslwr((wchar_t*)(str))
      #define FXSYS_wcsupr(str) _wcsupr((wchar_t*)(str))
    #else

      #define FXSYS_wcsicmp _wcsicmp

      #define FXSYS_WideCharToMultiByte WideCharToMultiByte

      #define FXSYS_MultiByteToWideChar MultiByteToWideChar

      #define FXSYS_wcslwr _wcslwr

      #define FXSYS_wcsupr _wcsupr
    #endif

    #ifndef _FX_WINAPI_PARTITION_DESKTOP_
      int      FXSYS_IntersectRect(struct FX_RECT*, const struct FX_RECT*, const struct FX_RECT*);
      int      FXSYS_GetACP(void);
      FX_DWORD  FXSYS_GetFullPathName(const char* filename, FX_DWORD buflen, char* buf, char** filepart);
      FX_DWORD  FXSYS_GetModuleFileName(void* hModule, char* buf, FX_DWORD bufsize);
    #else

      #define FXSYS_GetFullPathName GetFullPathName

      #define FXSYS_GetModuleFileName GetModuleFileName

      #define FXSYS_GetACP GetACP
    #endif
  #else
    char*    FXSYS_itoa(int value, char* string, int radix);
    int      FXSYS_GetACP(void);
    int      FXSYS_WideCharToMultiByte(FX_DWORD codepage, FX_DWORD dwFlags, const wchar_t* wstr, int wlen,
                char* buf, int buflen, const char* default_str, int* pUseDefault);
    int      FXSYS_MultiByteToWideChar(FX_DWORD codepage, FX_DWORD dwFlags, const char* bstr, int blen,
                wchar_t* buf, int buflen);
    FX_DWORD  FXSYS_GetFullPathName(const char* filename, FX_DWORD buflen, char* buf, char** filepart);
    FX_DWORD  FXSYS_GetModuleFileName(void* hModule, char* buf, FX_DWORD bufsize);

    char*    FXSYS_strlwr(char* str);
    char*    FXSYS_strupr(char* str);
    int      FXSYS_stricmp(const char*, const char*);
    int      FXSYS_wcsicmp(const wchar_t *string1, const wchar_t *string2);

    wchar_t*  FXSYS_wcslwr(wchar_t* str);
    wchar_t*  FXSYS_wcsupr(wchar_t* str);
  #endif
  //<<<+++OPENSOURCE_MUST_END

  //*****************************************************************************
  //* Memory utilities
  //*****************************************************************************

  void*    FXSYS_memcpy32(void* dst, const void* src, size_t size);

  FX_INT32  FXSYS_memcmp32(const void* buf1, const void* buf2, size_t size);

  void*    FXSYS_memset32(void* dst, FX_INT32 v, size_t size);

  void*    FXSYS_memset8(void* dst, FX_BYTE v, size_t size);

  void*    FXSYS_memmove32(void* dst, const void* src, size_t size);
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifdef __cplusplus
}
#endif
//<<<+++OPENSOURCE_MUST_END

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT

  #if _FX_OS_ == _FX_PALMOS_ && _FX_COMPILER_ == _FX_METROWERKS_
    #ifdef __cplusplus
      extern "C" {
    #endif

    /* Metrowerks for Palm OS (9.3) doesn't support standard math.h */
    extern double __ieee754_pow(double, double);
    extern double __ieee754_sqrt(double);
    extern double __fabs(double);
    extern double __ieee754_atan2(double, double);
    extern double __ceil(double);
    extern double __floor(double);
    extern double __cos(double);
    extern double __ieee754_acos(double);
    extern double __sin(double);
    extern double __ieee754_log(double);
    extern double __ieee754_log10(double);

    #define FXSYS_pow(x, y) __ieee754_pow(x, y)
    #define FXSYS_sqrt(x) __ieee754_sqrt(x)
    #define FXSYS_fabs(x) __fabs(x)
    #define FXSYS_atan2(x, y) __ieee754_atan2(x, y)
    #define FXSYS_ceil(x) __ceil(x)
    #define FXSYS_floor(x) __floor(x)
    #define FXSYS_cos(x) __cos(x)
    #define FXSYS_acos(x) __ieee754_acos(x)
    #define FXSYS_sin(x) __sin(x)
    #define FXSYS_log(x) __ieee754_log(x)
    #define FXSYS_log10(x) __ieee754_log10(x)

    #ifdef __cplusplus
    }
    #endif
  #else
    #include <math.h>
    #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_ || _FX_OS_ == _FX_LINUX_DESKTOP_

      #define FXSYS_pow powf

      #define FXSYS_sqrt sqrtf

      #define FXSYS_fabs fabsf

      #define FXSYS_atan2 atan2f

      #define FXSYS_ceil ceilf

      #define FXSYS_floor floorf

      #define FXSYS_cos cosf

      #define FXSYS_acos acosf

      #define FXSYS_sin sinf

      #define FXSYS_log logf

      #define FXSYS_log10 log10f

      #define FXSYS_fmod fmodf
    #else
      #define FXSYS_pow(a, b)    (FX_FLOAT)pow(a, b)
      #define FXSYS_sqrt(a)    (FX_FLOAT)sqrt(a)
      #define FXSYS_fabs(a)    (FX_FLOAT)fabs(a)
      #define FXSYS_atan2(a, b)  (FX_FLOAT)atan2(a, b)
      #define FXSYS_ceil(a)    (FX_FLOAT)ceil(a)
      #define FXSYS_floor(a)    (FX_FLOAT)floor(a)
      #define FXSYS_cos(a)    (FX_FLOAT)cos(a)
      #define FXSYS_acos(a)    (FX_FLOAT)acos(a)
      #define FXSYS_sin(a)    (FX_FLOAT)sin(a)
      #define FXSYS_log(a)    (FX_FLOAT)log(a)
      #define FXSYS_log10(a)    (FX_FLOAT)log10(a)
      #define FXSYS_fmod(a, b)  (FX_FLOAT)fmod(a, b)
    #endif
  #endif

  #if !defined(_FX_NO_ANSIC_)

    #define FXSYS_abs abs
  #else
    #define FXSYS_abs(a) ((a)<0?-(a):(a))
  #endif

  //<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifdef __cplusplus
extern "C" {
#endif
//<<<+++OPENSOURCE_MUST_END

  //<<<+++OPENSOURCE_MUST_BEGIN LIC==FOXIT
  #ifdef _FX_NO_GLOBAL_
    /* If platform doesn't support global variable, then we have to get from static functions */
    void    FXSYS_SetStaticPointer1(void*);
    void*    FXSYS_GetStaticPointer1(void);
    void    FXSYS_SetStaticPointer2(void*);
    void*    FXSYS_GetStaticPointer2(void);
  #endif

  /* CPU byte order */
  #if _FX_ENDIAN_ == _FX_BIG_ENDIAN_
    #define _FX_MSB_FIRST_
    #define FXDWORD_FROM_LSBFIRST(i) ( ((FX_BYTE)(i) << 24) | ((FX_BYTE)((i) >> 8) << 16) | ((FX_BYTE)((i) >> 16) << 8) | (FX_BYTE)((i) >> 24) )
    #define FXDWORD_FROM_MSBFIRST(i) (i)
  #else
    #define _FX_LSB_FIRST_
    #define FXDWORD_FROM_LSBFIRST(i) (i)
    #define FXDWORD_FROM_MSBFIRST(i) ( ((FX_BYTE)(i) << 24) | ((FX_BYTE)((i) >> 8) << 16) | ((FX_BYTE)((i) >> 16) << 8) | (FX_BYTE)((i) >> 24) )
  #endif

  #if _FX_CPU_ == _FX_X86_ || _FX_CPU_ == _FX_X64_ || _FX_CPU_ == _FX_ARM64_ || _FX_CPU_ == _FX_MIPS64_ || _FX_CPU_ == _FX_LOONGARCH64_ || _FX_CPU_ == _FX_SW64_
    #define FXDWORD_GET_LSBFIRST(p) (*(FX_DWORD*)(p))
  #else
    #define FXDWORD_GET_LSBFIRST(p) ((((FX_LPBYTE)(p))[3] << 24) | (((FX_LPBYTE)(p))[2] << 16) | (((FX_LPBYTE)(p))[1] << 8) | (((FX_LPBYTE)(p))[0]))
  #endif

#define FXDWORD_GET_MSBFIRST(p) ((((FX_LPBYTE)(p))[0] << 24) | (((FX_LPBYTE)(p))[1] << 16) | (((FX_LPBYTE)(p))[2] << 8) | (((FX_LPBYTE)(p))[3]))

#define FXSYS_HIBYTE(word)  ((FX_BYTE)((word) >> 8))
#define FXSYS_LOBYTE(word)  ((FX_BYTE)(word))
#define FXSYS_HIWORD(dword)  ((FX_WORD)((dword) >> 16))
#define FXSYS_LOWORD(dword)  ((FX_WORD)(dword))

#define    FXSYS_strtol strtol

FX_INT32  FXSYS_atoi(FX_LPCSTR str);
FX_INT32  FXSYS_wtoi(FX_LPCWSTR str);
FX_INT64  FXSYS_atoi64(FX_LPCSTR str);
FX_INT64  FXSYS_wtoi64(FX_LPCWSTR str);
FX_LPCSTR  FXSYS_i64toa(FX_INT64 value, FX_LPSTR str, int radix);
FX_LPCWSTR  FXSYS_i64tow(FX_INT64 value, FX_LPWSTR str, int radix);
int      FXSYS_round(FX_FLOAT f);
#define    FXSYS_Mul(a, b) ((a) * (b))

#define    FXSYS_Div(a, b) ((a) / (b))

#define    FXSYS_MulDiv(a, b, c) ((a) * (b) / (c))

#define    FXSYS_sqrt2(a, b) (FX_FLOAT)FXSYS_sqrt((a)*(a) + (b)*(b))

//*****************************************************************************
//* Multiple thread controls
//*****************************************************************************
#if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)
  typedef CRITICAL_SECTION  FX_MUTEX;
  FX_DEFINEHANDLE(FX_RWLOCK)
#elif _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_LINUX_EMBEDDED_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_
  #include <pthread.h>
  typedef pthread_mutex_t    FX_MUTEX;
  #if _FX_OS_ == _FX_ANDROID_
    FX_DEFINEHANDLE(FX_RWLOCK)
  #else
    typedef pthread_rwlock_t  FX_RWLOCK;
  #endif
#else
  FX_DEFINEHANDLE(FX_MUTEX)
  FX_DEFINEHANDLE(FX_RWLOCK)
#endif
// The following five functions are defined in fx_process.h, please refer there.
FX_BOOL  FX_Mutex_Initialize(FX_MUTEX* pMutex);
void    FX_Mutex_Destroy(FX_MUTEX* pMutex);
FX_BOOL  FX_Mutex_TryLock(FX_MUTEX* pMutex);
void    FX_Mutex_Lock(FX_MUTEX* pMutex);
void    FX_Mutex_Unlock(FX_MUTEX* pMutex);

#define FX_CRITICAL_SECTION    FX_MUTEX
#define FX_InitializeCriticalSection(a)    FX_Mutex_Initialize(a)
#define FX_DeleteCriticalSection(a)      FX_Mutex_Destroy(a)
#define FX_TryEnterCriticalSection(a)    FX_Mutex_TryLock(a)
#define FX_EnterCriticalSection(a)      FX_Mutex_Lock(a)
#define FX_LeaveCriticalSection(a)      FX_Mutex_Unlock(a)

#if (_FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN32_MOBILE_ || _FX_OS_ == _FX_WIN64_) && !defined(_FX_NO_WINDOWS_)
  typedef void*    FX_SPINLOCK;
#elif _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_==_FX_LINUX_EMBEDDED_
  #ifdef _FX_SPINLOCK_USEGCCCAS_
    typedef size_t    FX_SPINLOCK;
  #else
#ifndef _CHROME_PNACL_
    typedef pthread_spinlock_t  FX_SPINLOCK;
#else
    typedef size_t    FX_SPINLOCK;
#endif
  #endif
#elif _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
  typedef OSSpinLock  FX_SPINLOCK;
#else // android/embeded linux/other os
  FX_DEFINEHANDLE(FX_SPINLOCK)
#endif
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_MUST_BEGIN
#ifdef __cplusplus
};
#endif
//<<<+++OPENSOURCE_MUST_END

#if _FX_OS_ == _FX_PALMOS_ && _FX_COMPILER_ == _FX_PACC_
  #include <errtrycatch.h>
  #define setjmp ErrSetJump
  #define longjmp ErrLongJump
  #define jmp_buf ErrJumpBuf
#else
  #include <setjmp.h>
#endif

#if _FX_OS_ == _FX_MACOSX_
  #include <Carbon/Carbon.h>
#elif _FX_OS_ == _FX_IOS_
  #include <CoreText/CoreText.h>
  #include <CoreGraphics/CoreGraphics.h>
#endif
//<<<+++OPENSOURCE_MUST_END
//<<<+++OPENSOURCE_MUST_BEGIN
#endif  /* _FPDF_SYSTEM_H_ */
//<<<+++OPENSOURCE_MUST_END

//<<<+++OPENSOURCE_END