1HEADmaster

1 files changed, 2536 insertions, 0 deletions

diff --git a/common/quicktime_win32/fp.h b/common/quicktime_win32/fp.h
new file mode 100644
index 0000000..0426082
--- /dev/null
+++ b/common/quicktime_win32/fp.h
@@ -0,0 +1,2536 @@
+/*
+     File:       fp.h
+ 
+     Contains:   FPCE Floating-Point Definitions and Declarations.
+ 
+     Version:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 1987-2001 by Apple Computer, Inc., all rights reserved.
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __FP__
+#define __FP__
+
+#ifndef __CONDITIONALMACROS__
+#include <ConditionalMacros.h>
+#endif
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+/********************************************************************************
+*                                                                               *
+*    A collection of numerical functions designed to facilitate a wide          *
+*    range of numerical programming as required by C9X.                         *
+*                                                                               *
+*    The <fp.h> declares many functions in support of numerical programming.    *
+*    It provides a superset of <math.h> and <SANE.h> functions.  Some           *
+*    functionality previously found in <SANE.h> and not in the FPCE <fp.h>      *
+*    can be found in this <fp.h> under the heading "__NOEXTENSIONS__".          *
+*                                                                               *
+*    All of these functions are IEEE 754 aware and treat exceptions, NaNs,      *
+*    positive and negative zero and infinity consistent with the floating-      *
+*    point standard.                                                            *
+*                                                                               *
+********************************************************************************/
+
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if PRAGMA_IMPORT
+#pragma import on
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack(2)
+#endif
+
+/********************************************************************************
+*                                                                               *
+*                            Efficient types                                    *
+*                                                                               *
+*    float_t         Most efficient type at least as wide as float              *
+*    double_t        Most efficient type at least as wide as double             *
+*                                                                               *
+*      CPU            float_t(bits)                double_t(bits)               *
+*    --------        -----------------            -----------------             *
+*    PowerPC          float(32)                    double(64)                   *
+*    68K              long double(80/96)           long double(80/96)           *
+*    x86              double(64)                   double(64)                   *
+*                                                                               *
+********************************************************************************/
+#if (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__))
+/* these types were already defined in math.h */
+#else
+#if TARGET_CPU_PPC
+typedef float                           float_t;
+typedef double                          double_t;
+#elif TARGET_CPU_68K
+typedef long double                     float_t;
+typedef long double                     double_t;
+#elif TARGET_CPU_X86
+//typedef double                          float_t;
+typedef double                          double_t;
+#elif TARGET_CPU_MIPS
+typedef double                          float_t;
+typedef double                          double_t;
+#elif TARGET_CPU_ALPHA
+typedef double                          float_t;
+typedef double                          double_t;
+#elif TARGET_CPU_SPARC
+typedef double                          float_t;
+typedef double                          double_t;
+#else
+#error unsupported CPU
+#endif  /*  */
+
+/********************************************************************************
+*                                                                               *
+*                              Define some constants.                           *
+*                                                                               *
+*    HUGE_VAL            IEEE 754 value of infinity.                            *
+*    INFINITY            IEEE 754 value of infinity.                            *
+*    NAN                 A generic NaN (Not A Number).                          *
+*    DECIMAL_DIG         Satisfies the constraint that the conversion from      *
+*                        double to decimal and back is the identity function.   *
+*                                                                               *
+********************************************************************************/
+#if TARGET_OS_MAC
+  #if !TARGET_RT_MAC_MACHO
+    #define   HUGE_VAL                __inf()
+    #define   INFINITY                __inf()
+    #define   NAN                     nan("255")
+  #endif
+#else
+  //#define     NAN                     sqrt(-1)
+#endif
+
+#if TARGET_CPU_PPC
+  #define      DECIMAL_DIG              17 /* does not exist for double-double */
+#elif TARGET_CPU_68K
+  #define      DECIMAL_DIG              21
+#endif      
+#endif  /* (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__)) */
+#if TARGET_OS_MAC
+/* MSL or math.h already defines these */
+#if (!defined(__MWERKS__) || !defined(__cmath__)) && (!TARGET_RT_MAC_MACHO || !defined(__MATH__))
+/********************************************************************************
+*                                                                               *
+*                            Trigonometric functions                            *
+*                                                                               *
+*   acos        result is in [0,pi].                                            *
+*   asin        result is in [-pi/2,pi/2].                                      *
+*   atan        result is in [-pi/2,pi/2].                                      *
+*   atan2       Computes the arc tangent of y/x in [-pi,pi] using the sign of   *
+*               both arguments to determine the quadrant of the computed value. *
+*                                                                               *
+********************************************************************************/
+/*
+ *  cos()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) cos(double_t x);
+
+
+/*
+ *  sin()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) sin(double_t x);
+
+
+/*
+ *  tan()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) tan(double_t x);
+
+
+/*
+ *  acos()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) acos(double_t x);
+
+
+/*
+ *  asin()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) asin(double_t x);
+
+
+/*
+ *  atan()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) atan(double_t x);
+
+
+/*
+ *  atan2()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) atan2(double_t y, double_t x);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                              Hyperbolic functions                             *
+*                                                                               *
+********************************************************************************/
+/*
+ *  cosh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) cosh(double_t x);
+
+
+/*
+ *  sinh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) sinh(double_t x);
+
+
+/*
+ *  tanh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) tanh(double_t x);
+
+
+/*
+ *  acosh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) acosh(double_t x);
+
+
+/*
+ *  asinh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) asinh(double_t x);
+
+
+/*
+ *  atanh()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) atanh(double_t x);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                              Exponential functions                            *
+*                                                                               *
+*   expm1       expm1(x) = exp(x) - 1.  But, for small enough arguments,        *
+*               expm1(x) is expected to be more accurate than exp(x) - 1.       *
+*   frexp       Breaks a floating-point number into a normalized fraction       *
+*               and an integral power of 2.  It stores the integer in the       *
+*               object pointed by *exponent.                                    *
+*   ldexp       Multiplies a floating-point number by an integer power of 2.    *
+*   log1p       log1p = log(1 + x). But, for small enough arguments,            *
+*               log1p is expected to be more accurate than log(1 + x).          *
+*   logb        Extracts the exponent of its argument, as a signed integral     *
+*               value. A subnormal argument is treated as though it were first  *
+*               normalized. Thus:                                               *
+*                                  1   <=   x * 2^(-logb(x))   <   2            *
+*   modf        Returns fractional part of x as function result and returns     *
+*               integral part of x via iptr. Note C9X uses double not double_t. *
+*   scalb       Computes x * 2^n efficently.  This is not normally done by      *
+*               computing 2^n explicitly.                                       *
+*                                                                               *
+********************************************************************************/
+/*
+ *  exp()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) exp(double_t x);
+
+
+/*
+ *  expm1()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) expm1(double_t x);
+
+
+/*
+ *  exp2()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) exp2(double_t x);
+
+
+/*
+ *  frexp()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) frexp(double_t x, int *exponent);
+
+
+/*
+ *  ldexp()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) ldexp(double_t x, int n);
+
+
+/*
+ *  log()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) log(double_t x);
+
+
+/*
+ *  log2()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) log2(double_t x);
+
+
+/*
+ *  log1p()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) log1p(double_t x);
+
+
+/*
+ *  log10()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) log10(double_t x);
+
+
+/*
+ *  logb()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) logb(double_t x);
+
+
+#if !TYPE_LONGDOUBLE_IS_DOUBLE
+/*
+ *  modfl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) modfl(long double x, long double *iptrl);
+
+
+#endif  /* !TYPE_LONGDOUBLE_IS_DOUBLE */
+
+/*
+ *  modf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) modf(double_t x, double_t *iptr);
+
+
+/*
+ *  modff()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( float ) modff(float x, float *iptrf);
+
+
+
+/*
+    Note: For compatiblity scalb(x,n) has n of type
+            int  on Mac OS X 
+            long on Mac OS
+*/
+typedef long                            _scalb_n_type;
+/*
+ *  scalb()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) scalb(double_t x, _scalb_n_type n);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                     Power and absolute value functions                        *
+*                                                                               *
+*   hypot       Computes the square root of the sum of the squares of its       *
+*               arguments, without undue overflow or underflow.                 *
+*   pow         Returns x raised to the power of y.  Result is more accurate    *
+*               than using exp(log(x)*y).                                       *
+*                                                                               *
+********************************************************************************/
+/*
+ *  fabs()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) fabs(double_t x);
+
+
+/*
+ *  hypot()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) hypot(double_t x, double_t y);
+
+
+/*
+ *  pow()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 2.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) pow(double_t x, double_t y);
+
+
+/*
+ *  sqrt()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) sqrt(double_t x);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                        Gamma and Error functions                              *
+*                                                                               *
+*   erf         The error function.                                             *
+*   erfc        Complementary error function.                                   *
+*   gamma       The gamma function.                                             *
+*   lgamma      Computes the base-e logarithm of the absolute value of          *
+*               gamma of its argument x, for x > 0.                             *
+*                                                                               *
+********************************************************************************/
+/*
+ *  erf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) erf(double_t x);
+
+
+/*
+ *  erfc()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) erfc(double_t x);
+
+
+/*
+ *  gamma()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) gamma(double_t x);
+
+
+/*
+ *  lgamma()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) lgamma(double_t x);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                        Nearest integer functions                              *
+*                                                                               *
+*   rint        Rounds its argument to an integral value in floating point      *
+*               format, honoring the current rounding direction.                *
+*                                                                               *
+*   nearbyint   Differs from rint only in that it does not raise the inexact    *
+*               exception. It is the nearbyint function recommended by the      *
+*               IEEE floating-point standard 854.                               *
+*                                                                               *
+*   rinttol     Rounds its argument to the nearest long int using the current   *
+*               rounding direction.  NOTE: if the rounded value is outside      *
+*               the range of long int, then the result is undefined.            *
+*                                                                               *
+*   round       Rounds the argument to the nearest integral value in floating   *
+*               point format similar to the Fortran "anint" function. That is:  *
+*               add half to the magnitude and chop.                             *
+*                                                                               *
+*   roundtol    Similar to the Fortran function nint or to the Pascal round.    *
+*               NOTE: if the rounded value is outside the range of long int,    *
+*               then the result is undefined.                                   *
+*                                                                               *
+*   trunc       Computes the integral value, in floating format, nearest to     *
+*               but no larger in magnitude than its argument.   NOTE: on 68K    *
+*               compilers when using -elems881, trunc must return an int        *
+*                                                                               *
+********************************************************************************/
+/*
+ *  ceil()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) ceil(double_t x);
+
+
+/*
+ *  floor()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) floor(double_t x);
+
+
+/*
+ *  rint()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) rint(double_t x);
+
+
+/*
+ *  nearbyint()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) nearbyint(double_t x);
+
+
+/*
+ *  rinttol()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) rinttol(double_t x);
+
+
+/*
+ *  round()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) round(double_t x);
+
+
+/*
+ *  roundtol()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) roundtol(double_t round);
+
+
+/*
+    Note: For compatiblity trunc(x) has a return type of
+            int       for classic 68K with FPU enabled
+            double_t  everywhere else
+*/
+#if TARGET_RT_MAC_68881
+typedef int                             _trunc_return_type;
+#else
+typedef double_t                        _trunc_return_type;
+#endif  /* TARGET_RT_MAC_68881 */
+
+/*
+ *  trunc()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( _trunc_return_type ) trunc(double_t x);
+
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                            Remainder functions                                *
+*                                                                               *
+*   remainder       IEEE 754 floating point standard for remainder.             *
+*   remquo          SANE remainder.  It stores into 'quotient' the 7 low-order  *
+*                   bits of the integer quotient x/y, such that:                *
+*                       -127 <= quotient <= 127.                                *
+*                                                                               *
+********************************************************************************/
+/*
+ *  fmod()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) fmod(double_t x, double_t y);
+
+
+/*
+ *  remainder()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) remainder(double_t x, double_t y);
+
+
+/*
+ *  remquo()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) remquo(double_t x, double_t y, int *quo);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                             Auxiliary functions                               *
+*                                                                               *
+*   copysign        Produces a value with the magnitude of its first argument   *
+*                   and sign of its second argument.  NOTE: the order of the    *
+*                   arguments matches the recommendation of the IEEE 754        *
+*                   floating point standard,  which is opposite from the SANE   *
+*                   copysign function.                                          *
+*                                                                               *
+*   nan             The call 'nan("n-char-sequence")' returns a quiet NaN       *
+*                   with content indicated through tagp in the selected         *
+*                   data type format.                                           *
+*                                                                               *
+*   nextafter       Computes the next representable value after 'x' in the      *
+*                   direction of 'y'.  if x == y, then y is returned.           *
+*                                                                               *
+********************************************************************************/
+/*
+ *  copysign()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) copysign(double_t x, double_t y);
+
+
+/*
+ *  nan()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double ) nan(const char * tagp);
+
+
+/*
+ *  nanf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( float ) nanf(const char * tagp);
+
+
+
+/*
+ *  nanl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) nanl(const char * tagp);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) nanl(const char *tagp) { return (long double) nan(tagp); }
+  #else
+    #define nanl(tagp) ((long double) nan(tagp))
+  #endif
+#endif
+
+
+/*
+ *  nextafterd()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double ) nextafterd(double x, double y);
+
+
+/*
+ *  nextafterf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( float ) nextafterf(float x, float y);
+
+
+
+/*
+ *  nextafterl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) nextafterl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) nextafterl(long double x, long double y) { return (long double) nextafterd((double)(x),(double)(y)); }
+  #else
+    #define nextafterl(x, y) ((long double) nextafterd((double)(x),(double)(y)))
+  #endif
+#endif
+
+
+
+
+/*
+ *  __fpclassifyd()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __fpclassifyd(double x);
+
+
+/*
+ *  __fpclassifyf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __fpclassifyf(float x);
+
+
+
+/*
+ *  __fpclassify()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) __fpclassify(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) __fpclassify(long double x) { return __fpclassifyd((double)(x)); }
+  #else
+    #define __fpclassify(x) (__fpclassifyd((double)(x)))
+  #endif
+#endif
+
+
+/*
+ *  __isnormald()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isnormald(double x);
+
+
+/*
+ *  __isnormalf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isnormalf(float x);
+
+
+
+/*
+ *  __isnormal()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) __isnormal(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) __isnormal(long double x) { return __isnormald((double)(x)); }
+  #else
+    #define __isnormal(x) (__isnormald((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  __isfinited()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isfinited(double x);
+
+
+/*
+ *  __isfinitef()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isfinitef(float x);
+
+
+
+/*
+ *  __isfinite()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) __isfinite(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) __isfinite(long double x) { return __isfinited((double)(x)); }
+  #else
+    #define __isfinite(x) (__isfinited((double)(x)))
+  #endif
+#endif
+
+
+/*
+ *  __isnand()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isnand(double x);
+
+
+/*
+ *  __isnanf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __isnanf(float x);
+
+
+
+/*
+ *  __isnan()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) __isnan(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) __isnan(long double x) { return __isnand((double)(x)); }
+  #else
+    #define __isnan(x) (__isnand((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  __signbitd()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __signbitd(double x);
+
+
+/*
+ *  __signbitf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) __signbitf(float x);
+
+
+
+/*
+ *  __signbit()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) __signbit(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) __signbit(long double x) { return __signbitd((double)(x)); }
+  #else
+    #define __signbit(x) (__signbitd((double)(x)))
+  #endif
+#endif
+
+
+/*
+ *  __inf()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) __inf(void);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                              Inquiry macros                                   *
+*                                                                               *
+*   fpclassify      Returns one of the FP_* values.                             *
+*   isnormal        Non-zero if and only if the argument x is normalized.       *
+*   isfinite        Non-zero if and only if the argument x is finite.           *
+*   isnan           Non-zero if and only if the argument x is a NaN.            *
+*   signbit         Non-zero if and only if the sign of the argument x is       *
+*                   negative.  This includes, NaNs, infinities and zeros.       *
+*                                                                               *
+********************************************************************************/
+enum {
+  FP_SNAN                       = 0,    /*      signaling NaN                         */
+  FP_QNAN                       = 1,    /*      quiet NaN                             */
+  FP_INFINITE                   = 2,    /*      + or - infinity                       */
+  FP_ZERO                       = 3,    /*      + or - zero                           */
+  FP_NORMAL                     = 4,    /*      all normal numbers                    */
+  FP_SUBNORMAL                  = 5     /*      denormal numbers                      */
+};
+
+#define      fpclassify(x)    ( ( sizeof ( x ) == sizeof(double) ) ?           \
+                              __fpclassifyd  ( x ) :                           \
+                                ( sizeof ( x ) == sizeof(float) ) ?            \
+                              __fpclassifyf ( x ) :                            \
+                              __fpclassify  ( x ) )
+#define      isnormal(x)      ( ( sizeof ( x ) == sizeof(double) ) ?           \
+                              __isnormald ( x ) :                              \
+                                ( sizeof ( x ) == sizeof(float) ) ?            \
+                              __isnormalf ( x ) :                              \
+                              __isnormal  ( x ) )
+#define      isfinite(x)      ( ( sizeof ( x ) == sizeof(double) ) ?           \
+                              __isfinited ( x ) :                              \
+                                ( sizeof ( x ) == sizeof(float) ) ?            \
+                              __isfinitef ( x ) :                              \
+                              __isfinite  ( x ) )
+#define      isnan(x)         ( ( sizeof ( x ) == sizeof(double) ) ?           \
+                              __isnand ( x ) :                                 \
+                                ( sizeof ( x ) == sizeof(float) ) ?            \
+                              __isnanf ( x ) :                                 \
+                              __isnan  ( x ) )
+#define      signbit(x)       ( ( sizeof ( x ) == sizeof(double) ) ?           \
+                              __signbitd ( x ) :                               \
+                                ( sizeof ( x ) == sizeof(float) ) ?            \
+                              __signbitf ( x ) :                               \
+                              __signbit  ( x ) )
+
+
+
+/********************************************************************************
+*                                                                               *
+*                      Max, Min and Positive Difference                         *
+*                                                                               *
+*   fdim        Determines the 'positive difference' between its arguments:     *
+*               { x - y, if x > y }, { +0, if x <= y }.  If one argument is     *
+*               NaN, then fdim returns that NaN.  if both arguments are NaNs,   *
+*               then fdim returns the first argument.                           *
+*                                                                               *
+*   fmax        Returns the maximum of the two arguments.  Corresponds to the   *
+*               max function in FORTRAN.  NaN arguments are treated as missing  *
+*               data.  If one argument is NaN and the other is a number, then   *
+*               the number is returned.  If both are NaNs then the first        *
+*               argument is returned.                                           *
+*                                                                               *
+*   fmin        Returns the minimum of the two arguments.  Corresponds to the   *
+*               min function in FORTRAN.  NaN arguments are treated as missing  *
+*               data.  If one argument is NaN and the other is a number, then   *
+*               the number is returned.  If both are NaNs then the first        *
+*               argument is returned.                                           *
+*                                                                               *
+********************************************************************************/
+/*
+ *  fdim()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) fdim(double_t x, double_t y);
+
+
+/*
+ *  fmax()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) fmax(double_t x, double_t y);
+
+
+/*
+ *  fmin()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) fmin(double_t x, double_t y);
+
+
+#endif /* (defined(__MWERKS__) && defined(__cmath__)) || (TARGET_RT_MAC_MACHO && defined(__MATH__)) */
+
+/*******************************************************************************
+*                                Constants                                     *
+*******************************************************************************/
+/*
+ *  pi
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+extern const double_t pi;
+/********************************************************************************
+*                                                                               *
+*                              Non NCEG extensions                              *
+*                                                                               *
+********************************************************************************/
+#ifndef __NOEXTENSIONS__
+/********************************************************************************
+*                                                                               *
+*                              Financial functions                              *
+*                                                                               *
+*   compound        Computes the compound interest factor "(1 + rate)^periods"  *
+*                   more accurately than the straightforward computation with   *
+*                   the Power function.  This is SANE's compound function.      *
+*                                                                               *
+*   annuity         Computes the present value factor for an annuity            *
+*                   "(1 - (1 + rate)^(-periods)) /rate" more accurately than    *
+*                   the straightforward computation with the Power function.    *
+*                   This is SANE's annuity function.                            *
+*                                                                               *
+********************************************************************************/
+/*
+ *  compound()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) compound(double_t rate, double_t periods);
+
+
+/*
+ *  annuity()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) annuity(double_t rate, double_t periods);
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                              Random function                                  *
+*                                                                               *
+*   randomx         A pseudorandom number generator.  It uses the iteration:    *
+*                               (7^5*x)mod(2^31-1)                              *
+*                                                                               *
+********************************************************************************/
+/*
+ *  randomx()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) randomx(double_t * x);
+
+
+
+
+/*******************************************************************************
+*                              Relational operator                             *
+*******************************************************************************/
+/*      relational operator      */
+typedef short                           relop;
+enum {
+  GREATERTHAN                   = 0,
+  LESSTHAN                      = 1,
+  EQUALTO                       = 2,
+  UNORDERED                     = 3
+};
+
+#if !defined(__MWERKS__) || !defined(__cmath__)
+/*
+ *  relation()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( relop ) relation(double_t x, double_t y);
+
+
+#endif /* !defined(__MWERKS__) || !defined(__cmath__) */
+
+
+/********************************************************************************
+*                                                                               *
+*                         Binary to decimal conversions                         *
+*                                                                               *
+*   SIGDIGLEN   Significant decimal digits.                                     *
+*                                                                               *
+*   decimal     A record which provides an intermediate unpacked form for       *
+*               programmers who wish to do their own parsing of numeric input   *
+*               or formatting of numeric output.                                *
+*                                                                               *
+*   decform     Controls each conversion to a decimal string.  The style field  *
+*               is either FLOATDECIMAL or FIXEDDECIMAL. If FLOATDECIMAL, the    *
+*               value of the field digits is the number of significant digits.  *
+*               If FIXEDDECIMAL value of the field digits is the number of      *
+*               digits to the right of the decimal point.                       *
+*                                                                               *
+*   num2dec     Converts a double_t to a decimal record using a decform.        *
+*   dec2num     Converts a decimal record d to a double_t value.                *
+*   dec2str     Converts a decform and decimal to a string using a decform.     *
+*   str2dec     Converts a string to a decimal struct.                          *
+*   dec2d       Similar to dec2num except a double is returned (68k only).      *
+*   dec2f       Similar to dec2num except a float is returned.                  *
+*   dec2s       Similar to dec2num except a short is returned.                  *
+*   dec2l       Similar to dec2num except a long is returned.                   *
+*                                                                               *
+********************************************************************************/
+#if TARGET_CPU_PPC
+    #define SIGDIGLEN      36  
+#elif TARGET_CPU_68K
+    #define SIGDIGLEN      20
+#elif TARGET_CPU_X86
+    #define SIGDIGLEN      20
+#endif
+#define      DECSTROUTLEN   80               /* max length for dec2str output */
+#define      FLOATDECIMAL   ((char)(0))
+#define      FIXEDDECIMAL   ((char)(1))
+struct decimal {
+    char                            sgn;                        /* sign 0 for +, 1 for - */
+    char                            unused;
+    short                           exp;                        /* decimal exponent */
+    struct {
+        unsigned char                   length;
+        unsigned char                   text[SIGDIGLEN];        /* significant digits */
+        unsigned char                   unused;
+    }                               sig;
+};
+typedef struct decimal decimal;
+
+struct decform {
+    char                            style;                      /*  FLOATDECIMAL or FIXEDDECIMAL */
+    char                            unused;
+    short                           digits;
+};
+typedef struct decform decform;
+/*
+ *  num2dec()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void ) num2dec(const decform *f, double_t x, decimal *d);
+
+
+/*
+ *  dec2num()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double_t ) dec2num(const decimal * d);
+
+
+/*
+ *  dec2str()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void ) dec2str(const decform *f, const decimal *d, char *s);
+
+
+/*
+ *  str2dec()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void ) str2dec(const char *s, short *ix, decimal *d, short *vp);
+
+
+#if TARGET_CPU_68K
+#if CALL_NOT_IN_CARBON
+/*
+ *  dec2d()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( double ) dec2d(const decimal * d);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#endif  /* TARGET_CPU_68K */
+
+/*
+ *  dec2f()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( float ) dec2f(const decimal * d);
+
+
+/*
+ *  dec2s()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( short ) dec2s(const decimal * d);
+
+
+/*
+ *  dec2l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( long ) dec2l(const decimal * d);
+
+
+
+
+
+/********************************************************************************
+*                                                                               *
+*                         68k-only Transfer Function Prototypes                 *
+*                                                                               *
+********************************************************************************/
+#if TARGET_CPU_68K
+#if CALL_NOT_IN_CARBON
+/*
+ *  x96tox80()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void ) x96tox80(const extended96 *x, extended80 *x80);
+
+
+/*
+ *  x80tox96()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void ) x80tox96(const extended80 *x80, extended96 *x);
+
+
+#endif  /* CALL_NOT_IN_CARBON */
+
+#endif  /* TARGET_CPU_68K */
+
+#endif  /* !defined(__NOEXTENSIONS__) */
+
+/********************************************************************************
+*                                                                               *
+*                         PowerPC-only Function Prototypes                      *
+*                                                                               *
+********************************************************************************/
+
+#if TARGET_CPU_PPC
+#ifndef __MWERKS__  /* Metrowerks does not support double double */
+
+/*
+ *  cosl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) cosl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) cosl(long double x) { return (long double) cos((double)(x)); }
+  #else
+    #define cosl(x) ((long double) cos((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  sinl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) sinl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) sinl(long double x) { return (long double) sin((double)(x)); }
+  #else
+    #define sinl(x) ((long double) sin((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  tanl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) tanl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) tanl(long double x) { return (long double) tan((double)(x)); }
+  #else
+    #define tanl(x) ((long double) tan((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  acosl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) acosl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) acosl(long double x) { return (long double) acos((double)(x)); }
+  #else
+    #define acosl(x) ((long double) acos((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  asinl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) asinl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) asinl(long double x) { return (long double) asin((double)(x)); }
+  #else
+    #define asinl(x) ((long double) asin((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  atanl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) atanl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) atanl(long double x) { return (long double) atan((double)(x)); }
+  #else
+    #define atanl(x) ((long double) atan((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  atan2l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) atan2l(long double y, long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) atan2l(long double y, long double x) { return (long double) atan2((double)(y), (double)(x)); }
+  #else
+    #define atan2l(y, x) ((long double) atan2((double)(y), (double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  coshl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) coshl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) coshl(long double x) { return (long double) cosh((double)(x)); }
+  #else
+    #define coshl(x) ((long double) cosh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  sinhl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) sinhl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) sinhl(long double x) { return (long double) sinh((double)(x)); }
+  #else
+    #define sinhl(x) ((long double) sinh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  tanhl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) tanhl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) tanhl(long double x) { return (long double) tanh((double)(x)); }
+  #else
+    #define tanhl(x) ((long double) tanh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  acoshl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) acoshl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) acoshl(long double x) { return (long double) acosh((double)(x)); }
+  #else
+    #define acoshl(x) ((long double) acosh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  asinhl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) asinhl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) asinhl(long double x) { return (long double) asinh((double)(x)); }
+  #else
+    #define asinhl(x) ((long double) asinh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  atanhl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) atanhl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) atanhl(long double x) { return (long double) atanh((double)(x)); }
+  #else
+    #define atanhl(x) ((long double) atanh((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  expl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) expl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) expl(long double x) { return (long double) exp((double)(x)); }
+  #else
+    #define expl(x) ((long double) exp((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  expm1l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) expm1l(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) expm1l(long double x) { return (long double) expm1((double)(x)); }
+  #else
+    #define expm1l(x) ((long double) expm1((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  exp2l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) exp2l(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) exp2l(long double x) { return (long double) exp2((double)(x)); }
+  #else
+    #define exp2l(x) ((long double) exp2((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  frexpl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) frexpl(long double x, int *exponent);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) frexpl(long double x, int *exponent) { return (long double) frexp((double)(x), (exponent)); }
+  #else
+    #define frexpl(x, exponent) ((long double) frexp((double)(x), (exponent)))
+  #endif
+#endif
+
+
+
+/*
+ *  ldexpl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) ldexpl(long double x, int n);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) ldexpl(long double x, int n) { return (long double) ldexp((double)(x), (n)); }
+  #else
+    #define ldexpl(x, n) ((long double) ldexp((double)(x), (n)))
+  #endif
+#endif
+
+
+
+/*
+ *  logl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) logl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) logl(long double x) { return (long double) log((double)(x)); }
+  #else
+    #define logl(x) ((long double) log((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  log1pl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) log1pl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) log1pl(long double x) { return (long double) log1p((double)(x)); }
+  #else
+    #define log1pl(x) ((long double) log1p((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  log10l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) log10l(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) log10l(long double x) { return (long double) log10((double)(x)); }
+  #else
+    #define log10l(x) ((long double) log10((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  log2l()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) log2l(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) log2l(long double x) { return (long double) log2((double)(x)); }
+  #else
+    #define log2l(x) ((long double) log2((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  logbl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) logbl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) logbl(long double x) { return (long double) logb((double)(x)); }
+  #else
+    #define logbl(x) ((long double) logb((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  scalbl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) scalbl(long double x, long n);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) scalbl(long double x, long n) { return (long double) scalb((double)(x), (n)); }
+  #else
+    #define scalbl(x, n) ((long double) scalb((double)(x), (n)))
+  #endif
+#endif
+
+
+
+/*
+ *  fabsl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) fabsl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) fabsl(long double x) { return (long double) fabs((double)(x)); }
+  #else
+    #define fabsl(x) ((long double) fabs((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  hypotl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) hypotl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) hypotl(long double x, long double y) { return (long double) hypot((double)(x), (double)(y)); }
+  #else
+    #define hypotl(x, y) ((long double) hypot((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  powl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) powl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) powl(long double x, long double y) { return (long double) pow((double)(x), (double)(y)); }
+  #else
+    #define powl(x, y) ((long double) pow((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  sqrtl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) sqrtl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) sqrtl(long double x) { return (long double) sqrt((double)(x)); }
+  #else
+    #define sqrtl(x) ((long double) sqrt((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  erfl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) erfl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) erfl(long double x) { return (long double) erf((double)(x)); }
+  #else
+    #define erfl(x) ((long double) erf((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  erfcl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) erfcl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) erfcl(long double x) { return (long double) erfc((double)(x)); }
+  #else
+    #define erfcl(x) ((long double) erfc((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  gammal()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) gammal(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) gammal(long double x) { return (long double) gamma((double)(x)); }
+  #else
+    #define gammal(x) ((long double) gamma((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  lgammal()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) lgammal(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) lgammal(long double x) { return (long double) lgamma((double)(x)); }
+  #else
+    #define lgammal(x) ((long double) lgamma((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  ceill()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 2.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) ceill(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) ceill(long double x) { return (long double) ceil((double)(x)); }
+  #else
+    #define ceill(x) ((long double) ceil((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  floorl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) floorl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) floorl(long double x) { return (long double) floor((double)(x)); }
+  #else
+    #define floorl(x) ((long double) floor((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  rintl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) rintl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) rintl(long double x) { return (long double) rint((double)(x)); }
+  #else
+    #define rintl(x) ((long double) rint((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  nearbyintl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) nearbyintl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) nearbyintl(long double x) { return (long double) nearbyint((double)(x)); }
+  #else
+    #define nearbyintl(x) ((long double) nearbyint((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  rinttoll()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) rinttoll(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) rinttoll(long double x) { return rinttol((double)(x)); }
+  #else
+    #define rinttoll(x) (rinttol((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  roundl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) roundl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) roundl(long double x) { return (long double) round((double)(x)); }
+  #else
+    #define roundl(x) ((long double) round((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  roundtoll()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long ) roundtoll(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long ) roundtoll(long double x) { return roundtol((double)(x)); }
+  #else
+    #define roundtoll(x) (roundtol((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  truncl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) truncl(long double x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) truncl(long double x) { return (long double) trunc((double)(x)); }
+  #else
+    #define truncl(x) ((long double) trunc((double)(x)))
+  #endif
+#endif
+
+
+
+/*
+ *  remainderl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) remainderl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) remainderl(long double x, long double y) { return (long double) remainder((double)(x), (double)(y)); }
+  #else
+    #define remainderl(x, y) ((long double) remainder((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  remquol()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) remquol(long double x, long double y, int *quo);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) remquol(long double x, long double y, int *quo) { return (long double) remquo((double)(x), (double)(y), (quo)); }
+  #else
+    #define remquol(x, y, quo) ((long double) remquo((double)(x), (double)(y), (quo)))
+  #endif
+#endif
+
+
+
+/*
+ *  copysignl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) copysignl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) copysignl(long double x, long double y) { return (long double) copysign((double)(x), (double)(y)); }
+  #else
+    #define copysignl(x, y) ((long double) copysign((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  fdiml()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) fdiml(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) fdiml(long double x, long double y) { return (long double) fdim((double)(x), (double)(y)); }
+  #else
+    #define fdiml(x, y) ((long double) fdim((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  fmaxl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) fmaxl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) fmaxl(long double x, long double y) { return (long double) fmax((double)(x), (double)(y)); }
+  #else
+    #define fmaxl(x, y) ((long double) fmax((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  fminl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) fminl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) fminl(long double x, long double y) { return (long double) fmin((double)(x), (double)(y)); }
+  #else
+    #define fminl(x, y) ((long double) fmin((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+#endif /* __MWERKS__ */
+#ifndef __NOEXTENSIONS__
+/*
+ *  relationl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( relop ) relationl(long double x, long double y);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(relop ) relationl(long double x, long double y) { return relation((double)(x), (double)(y)); }
+  #else
+    #define relationl(x, y) (relation((double)(x), (double)(y)))
+  #endif
+#endif
+
+
+
+/*
+ *  num2decl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void ) num2decl(const decform *f, long double x, decimal *d);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(void) num2decl(const decform *f, long double x, decimal *d) { num2dec((f), (double)(x), (d)); }
+  #else
+    #define num2decl(f, x, d) (num2dec((f), (double)(x), (d)))
+  #endif
+#endif
+
+
+
+/*
+ *  dec2numl()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( long double ) dec2numl(const decimal * d);
+#if TYPE_LONGDOUBLE_IS_DOUBLE
+  #ifdef __cplusplus
+    inline DEFINE_API_C(long double ) dec2numl(const decimal *d) { return (long double) dec2num(d); }
+  #else
+    #define dec2numl(d) ((long double) dec2num(d))
+  #endif
+#endif
+
+
+#endif  /* !defined(__NOEXTENSIONS__) */
+
+#endif  /* TARGET_CPU_PPC */
+
+#endif  /* TARGET_OS_MAC */
+
+#ifndef __NOEXTENSIONS__
+/*    
+        MathLib v2 has two new transfer functions: x80tod and dtox80.  They can 
+        be used to directly transform 68k 80-bit extended data types to double
+        and back for PowerPC based machines without using the functions
+        x80told or ldtox80.  Double rounding may occur. 
+    */
+/*
+ *  x80tod()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 2.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( double ) x80tod(const extended80 * x80);
+
+
+/*
+ *  dtox80()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 2.0 and later
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         in version 10.0 and later
+ */
+EXTERN_API_C( void ) dtox80(const double *x, extended80 *x80);
+
+
+/*
+ *  x80told()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void ) x80told(const extended80 *x80, long double *x);
+#if TYPE_LONGDOUBLE_IS_DOUBLE && !TARGET_OS_WIN32
+  #ifdef __cplusplus
+    inline DEFINE_API_C(void) x80told(const extended80 *x80, long double *x) { *(x) = (long double) x80tod(x80); }
+  #else
+    #define x80told(x80, x) (*(x) = (long double) x80tod(x80))
+  #endif
+#endif
+
+
+
+/*
+ *  ldtox80()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   in MathLib 1.0 and later or as macro/inline
+ *    CarbonLib:        in CarbonLib 1.0 and later
+ *    Mac OS X:         not available
+ */
+EXTERN_API_C( void ) ldtox80(const long double *x, extended80 *x80);
+#if TYPE_LONGDOUBLE_IS_DOUBLE && !TARGET_OS_WIN32
+  #ifdef __cplusplus
+    inline DEFINE_API_C(void) ldtox80(const long double *x, extended80 *x80) { double d = (double) *(x); dtox80(&d, (x80)); }
+  #else
+    #define ldtox80(x, x80) do { double d = (double) *(x); dtox80(&d, (x80)); } while (false)
+  #endif
+#endif
+
+
+#endif  /* !defined(__NOEXTENSIONS__) */
+
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __FP__ */
+