* the define to check for inclusion in the System unit is FPC_IS_SYSTEM, *not* FPC_IN_SYSTEM

git-svn-id: trunk@47197 -

rtl/inc/softfpu.pp

@@ -191,7 +191,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_lt(a: float64;b: float64): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_lt(a: float64;b: float64): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the double-precision floating-point value `a' is less than
@@ -200,7 +200,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_le(a: float64;b: float64): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_le(a: float64;b: float64): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the double-precision floating-point value `a' is equal to
@@ -208,7 +208,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_eq(a: float64;b: float64): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_eq(a: float64;b: float64): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the square root of the double-precision floating-point value `a'.
@@ -216,7 +216,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-function float64_sqrt( a: float64 ): float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+function float64_sqrt( a: float64 ): float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the remainder of the double-precision floating-point value `a'
@@ -224,7 +224,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_rem(a: float64; b : float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_rem(a: float64; b : float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of dividing the double-precision floating-point value `a'
@@ -232,7 +232,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_div(a: float64; b : float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_div(a: float64; b : float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of multiplying the double-precision floating-point values
@@ -240,7 +240,7 @@ Returns the result of multiplying the double-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_mul( a: float64; b:float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_mul( a: float64; b:float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of subtracting the double-precision floating-point values
@@ -248,7 +248,7 @@ Returns the result of subtracting the double-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_sub(a: float64; b : float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_sub(a: float64; b : float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of adding the double-precision floating-point values `a'
@@ -256,7 +256,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_add( a: float64; b : float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_add( a: float64; b : float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Rounds the double-precision floating-point value `a' to an integer,
@@ -265,7 +265,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_round_to_int(a: float64) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_round_to_int(a: float64) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -274,7 +274,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_float32(a: float64) : float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_to_float32(a: float64) : float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -286,7 +286,7 @@ the conversion overflows, the largest integer with the same sign as `a' is
 returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32_round_to_zero(a: float64 ): int32; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_to_int32_round_to_zero(a: float64 ): int32; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -298,7 +298,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32(a: float64): int32; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_to_int32(a: float64): int32; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is less than
@@ -306,7 +306,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_lt( a:float32rec ; b : float32rec): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_lt( a:float32rec ; b : float32rec): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is less than
@@ -315,7 +315,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_le( a: float32rec; b : float32rec ):flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_le( a: float32rec; b : float32rec ):flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is equal to
@@ -323,7 +323,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_eq( a:float32rec; b:float32rec): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_eq( a:float32rec; b:float32rec): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the square root of the single-precision floating-point value `a'.
@@ -331,7 +331,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sqrt(a: float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_sqrt(a: float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the remainder of the single-precision floating-point value `a'
@@ -339,7 +339,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_rem(a: float32rec; b: float32rec ):float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_rem(a: float32rec; b: float32rec ):float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of dividing the single-precision floating-point value `a'
@@ -347,7 +347,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_div(a: float32rec;b: float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_div(a: float32rec;b: float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of multiplying the single-precision floating-point values
@@ -355,7 +355,7 @@ Returns the result of multiplying the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_mul(a: float32rec; b: float32rec ) : float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_mul(a: float32rec; b: float32rec ) : float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of subtracting the single-precision floating-point values
@@ -363,7 +363,7 @@ Returns the result of subtracting the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sub( a: float32rec ; b:float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_sub( a: float32rec ; b:float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of adding the single-precision floating-point values `a'
@@ -371,7 +371,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_add( a: float32rec; b:float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_add( a: float32rec; b:float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Rounds the single-precision floating-point value `a' to an integer,
@@ -380,7 +380,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_round_to_int( a: float32rec): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_round_to_int( a: float32rec): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -389,7 +389,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_float64( a : float32rec) : Float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_float64( a : float32rec) : Float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -401,7 +401,7 @@ the conversion overflows, the largest integer with the same sign as `a' is
 returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32_round_to_zero( a: Float32rec ): int32; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_int32_round_to_zero( a: Float32rec ): int32; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -413,7 +413,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32( a : float32rec) : int32; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_int32( a : float32rec) : int32; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the 32-bit two's complement integer `a' to
@@ -421,7 +421,7 @@ the double-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float64( a: int32) : float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function int32_to_float64( a: int32) : float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the 32-bit two's complement integer `a' to
@@ -429,23 +429,23 @@ the single-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float32( a: int32): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function int32_to_float32( a: int32): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 
 {*----------------------------------------------------------------------------
 | Returns the result of converting the 64-bit two's complement integer `a'
 | to the double-precision floating-point format.  The conversion is performed
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
-Function int64_to_float64( a: int64 ): float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
-Function qword_to_float64( a: qword ): float64; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function int64_to_float64( a: int64 ): float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
+Function qword_to_float64( a: qword ): float64; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 
 {*----------------------------------------------------------------------------
 | Returns the result of converting the 64-bit two's complement integer `a'
 | to the single-precision floating-point format.  The conversion is performed
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
-Function int64_to_float32( a: int64 ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
-Function qword_to_float32( a: qword ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function int64_to_float32( a: int64 ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
+Function qword_to_float32( a: qword ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 
 // +++
 function float32_to_int64( a: float32 ): int64;
@@ -3013,7 +3013,7 @@ the single-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float32( a: int32): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function int32_to_float32( a: int32): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
  Var
   zSign : Flag;
  Begin
@@ -3043,7 +3043,7 @@ the double-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float64( a: int32) : float64;{$ifdef FPC_IN_SYSTEM} [public,Alias:'INT32_TO_FLOAT64'];compilerproc;{$endif}
+Function int32_to_float64( a: int32) : float64;{$ifdef FPC_IS_SYSTEM} [public,Alias:'INT32_TO_FLOAT64'];compilerproc;{$endif}
   var
     zSign : flag;
     absA : bits32;
@@ -3152,7 +3152,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32( a : float32rec) : int32;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_int32( a : float32rec) : int32;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -3239,7 +3239,7 @@ the conversion overflows, the largest integer with the same sign as `a' is
 returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32_round_to_zero( a: Float32rec ): int32;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_int32_round_to_zero( a: Float32rec ): int32;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
  Var
     aSign : flag;
     aExp, shiftCount : int16;
@@ -3374,7 +3374,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_float64( a : float32rec) : Float64;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_to_float64( a : float32rec) : Float64;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign : flag;
     aExp : int16;
@@ -3513,7 +3513,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_round_to_int( a: float32rec): float32rec;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_round_to_int( a: float32rec): float32rec;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign: flag;
     aExp: int16;
@@ -3811,7 +3811,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_add( a: float32rec; b:float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_add( a: float32rec; b:float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign, bSign: Flag;
   Begin
@@ -3834,7 +3834,7 @@ Returns the result of subtracting the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sub( a: float32rec ; b:float32rec ): float32rec;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_sub( a: float32rec ; b:float32rec ): float32rec;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign, bSign: flag;
   Begin
@@ -3857,7 +3857,7 @@ Returns the result of multiplying the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_mul(a: float32rec; b: float32rec ) : float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_mul(a: float32rec; b: float32rec ) : float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 
   Var
     aSign, bSign, zSign: flag;
@@ -3941,7 +3941,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_div(a: float32rec;b: float32rec ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_div(a: float32rec;b: float32rec ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -4041,7 +4041,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_rem(a: float32rec; b: float32rec ):float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_rem(a: float32rec; b: float32rec ):float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
   Var
     aSign, zSign: flag;
     aExp, bExp, expDiff: int16;
@@ -4159,7 +4159,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sqrt(a: float32rec ): float32rec;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_sqrt(a: float32rec ): float32rec;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 Var
     aSign : flag;
     aExp, zExp : int16;
@@ -4242,7 +4242,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_eq( a:float32rec; b:float32rec): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_eq( a:float32rec; b:float32rec): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 Begin
     if ((( extractFloat32Exp( a.float32 ) = $FF ) AND  (extractFloat32Frac( a.float32 )<>0))
          OR ( ( extractFloat32Exp( b.float32 ) = $FF ) AND  (extractFloat32Frac( b.float32 )<>0) )
@@ -4266,7 +4266,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_le( a: float32rec; b : float32rec ):flag;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_le( a: float32rec; b : float32rec ):flag;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 var
     aSign, bSign: flag;
 Begin
@@ -4297,7 +4297,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_lt( a:float32rec ; b : float32rec): flag; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float32_lt( a:float32rec ; b : float32rec): flag; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 var
     aSign, bSign: flag;
 Begin
@@ -4420,7 +4420,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32(a: float64): int32;{$ifdef FPC_IN_SYSTEM} [public,Alias:'FLOAT64_TO_INT32'];compilerproc;{$endif}
+Function float64_to_int32(a: float64): int32;{$ifdef FPC_IS_SYSTEM} [public,Alias:'FLOAT64_TO_INT32'];compilerproc;{$endif}
 var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -4517,7 +4517,7 @@ returned.
 -------------------------------------------------------------------------------
 *}
 Function float64_to_int32_round_to_zero(a: float64 ): int32;
-{$ifdef FPC_IN_SYSTEM} [public,Alias:'FLOAT64_TO_INT32_ROUND_TO_ZERO'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM} [public,Alias:'FLOAT64_TO_INT32_ROUND_TO_ZERO'];compilerproc;{$endif}
 Var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -4679,7 +4679,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_float32(a: float64 ): float32rec;{$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+Function float64_to_float32(a: float64 ): float32rec;{$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 Var
     aSign: flag;
     aExp: int16;
@@ -4756,7 +4756,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-function float64_round_to_int(a: float64) : Float64;{$ifdef FPC_IN_SYSTEM} [public,Alias:'FLOAT64_ROUND_TO_INT'];compilerproc;{$endif}
+function float64_round_to_int(a: float64) : Float64;{$ifdef FPC_IS_SYSTEM} [public,Alias:'FLOAT64_ROUND_TO_INT'];compilerproc;{$endif}
 
 Var
     aSign: flag;
@@ -5120,7 +5120,7 @@ Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_add( a: float64; b : float64) : Float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_ADD'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_ADD'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -5144,7 +5144,7 @@ for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_sub(a: float64; b : float64) : Float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_SUB'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_SUB'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -5168,7 +5168,7 @@ for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_mul( a: float64; b:float64) : Float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_MUL'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_MUL'];compilerproc;{$endif}
 Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -5257,7 +5257,7 @@ IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_div(a: float64; b : float64) : Float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_DIV'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_DIV'];compilerproc;{$endif}
 Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -5373,7 +5373,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_rem(a: float64; b : float64) : float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_REM'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_REM'];compilerproc;{$endif}
 Var
     aSign, zSign: flag;
     aExp, bExp, expDiff: int16;
@@ -5512,7 +5512,7 @@ Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 function float64_sqrt( a: float64 ): float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_SQRT'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_SQRT'];compilerproc;{$endif}
 Var
     aSign: flag;
     aExp, zExp: int16;
@@ -5607,7 +5607,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_eq(a: float64; b: float64): flag;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_EQ'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_EQ'];compilerproc;{$endif}
 Begin
     if
          (
@@ -5647,7 +5647,7 @@ Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_le(a: float64;b: float64): flag;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_LE'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_LE'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -5695,7 +5695,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_lt(a: float64;b: float64): flag;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'FLOAT64_LT'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'FLOAT64_LT'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -5878,7 +5878,7 @@ End;
 | to the single-precision floating-point format.  The conversion is performed
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
-function int64_to_float32( a: int64 ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+function int64_to_float32( a: int64 ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 var
     zSign : flag;
     absA : uint64;
@@ -5919,7 +5919,7 @@ End;
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 | Unisgned version.
 *----------------------------------------------------------------------------*}
-function qword_to_float32( a: qword ): float32rec; {$ifdef FPC_IN_SYSTEM}compilerproc;{$endif FPC_IN_SYSTEM}
+function qword_to_float32( a: qword ): float32rec; {$ifdef FPC_IS_SYSTEM}compilerproc;{$endif FPC_IS_SYSTEM}
 var
     absA : uint64;
     shiftCount: int8;
@@ -5953,7 +5953,7 @@ End;
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
 function qword_to_float64( a: qword ): float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'QWORD_TO_FLOAT64'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'QWORD_TO_FLOAT64'];compilerproc;{$endif}
 var
   shiftCount: int8;
 Begin
@@ -5984,7 +5984,7 @@ End;
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
 function int64_to_float64( a: int64 ): float64;
-{$ifdef FPC_IN_SYSTEM}[public,Alias:'INT64_TO_FLOAT64'];compilerproc;{$endif}
+{$ifdef FPC_IS_SYSTEM}[public,Alias:'INT64_TO_FLOAT64'];compilerproc;{$endif}
 Begin
   if ( a = 0 ) then
     result := packFloat64( 0, 0, 0 )