Changes made for C++Builder compatibility

Author: rvelthuis

Source/Velthuis.BigDecimals.pas

@@ -510,6 +510,19 @@   BigDecimal = record
     /// <para>Only the low 8 bits of myUInt64 are copied to the byte.</para></remarks>
     class operator Explicit(const Value: BigDecimal): Int64;
 
+    // -- Conversion functions --
+
+  {$IFDEF HasExtended}
+    function AsExtended: Extended;
+  {$ENDIF}
+    function AsDouble: Double;
+    function AsSingle: Single;
+    function AsBigInteger: BigInteger;
+    function AsUInt64: UInt64;
+    function AsInt64: Int64;
+    function AsUInt32: UInt32;
+    function AsInt32: Int32;
+
 
     // -- Mathematical functions --
 
@@ -942,6 +955,82 @@ class procedure BigDecimal.AdjustForRoundingMode(var Quotient: BigInteger; const
     end;
 end;
 
+  {$IFDEF HasExtended}
+    function BigDecimal.AsExtended: Extended;
+    begin
+
+    end;
+  {$ENDIF}
+
+    function BigDecimal.AsDouble: Double;
+    begin
+      Result := Double(Self);
+      if IsInfinite(Result) then
+        Error(ecConversion, ['BigDecimal', 'Double']);
+    end;
+
+    function BigDecimal.AsSingle: Single;
+    begin
+      Result := Single(Self);
+      if IsInfinite(Result) then
+        Error(ecConversion, ['BigDecimal', 'Single']);
+    end;
+
+    function BigDecimal.AsBigInteger: BigInteger;
+    begin
+      Result := BigInteger(Self);
+      if Self.Scale > 0 then
+        Error(ecRounding, []);
+    end;
+
+    function BigDecimal.AsUInt64: UInt64;
+    var
+      D: BigDecimal;
+    begin
+      D := Self.RoundToScale(0, rmUnnecessary); // Throws if rounding necessary
+      try
+        Result := D.UnscaledValue.AsUInt64;                   // Throws if too big
+      except
+        Error(ecConversion, ['BigDecimal', 'UInt64']);
+      end;
+    end;
+
+    function BigDecimal.AsInt64: Int64;
+    var
+      D: BigDecimal;
+    begin
+      D := Self.RoundToScale(0, rmUnnecessary);
+      try
+        Result := D.UnscaledValue.AsInt64;
+      finally
+        Error(ecConversion, ['BigDecimal', 'Int64']);
+      end;
+    end;
+
+    function BigDecimal.AsUInt32: UInt32;
+    var
+      D: BigDecimal;
+    begin
+      D := Self.RoundToScale(0, rmUnnecessary);
+      try
+        Result := D.UnscaledValue.AsCardinal;
+      finally
+        Error(ecConversion, ['BigDecimal', 'UInt32']);
+      end;
+    end;
+
+    function BigDecimal.AsInt32: Int32;
+    var
+      D: BigDecimal;
+    begin
+      D := Self.RoundToScale(0, rmUnnecessary);
+      try
+        Result := D.UnscaledValue.AsInteger;
+      finally
+        Error(ecConversion, ['BigDecimal', 'Int32']);
+      end;
+    end;
+
 // Does a "binary search" to remove trailing zeros. This is much faster (10 times or more) than repeatedly
 // dividing by BigInteger.Ten until there is a remainder, even for relatively small numbers of trailing zeros.
 // Since this modifies Value, it cannot be made public, but there is a public version of this, called

Source/Velthuis.BigIntegers.operators.hpp

@@ -1,5 +1,5 @@
-#ifndef VB_OPERATORS
-#define VB_OPERATORS
+#ifndef VBI_OPERATORS
+#define VBI_OPERATORS
 
 inline BigInteger operator +(const BigInteger& left, const BigInteger& right) { return BigInteger::Add(left, right); }
 inline BigInteger operator -(const BigInteger& left, const BigInteger& right) { return BigInteger::Subtract(left, right); }

Source/Velthuis.BigIntegers.pas

@@ -205,15 +205,15 @@ interface
 {$STACKFRAMES OFF}
 {$INLINE ON}
 
+{$IF CompilerVersion >= CompilerVersionDelphiXE3}
+  {$LEGACYIFEND ON}
+{$IFEND}
+
 {$IF CompilerVersion >= CompilerVersionDelphiXE}
   {$CODEALIGN 16}
   {$ALIGN 16}
 {$IFEND}
 
-{$IF CompilerVersion >= CompilerVersionDelphiXE3}
-  {$LEGACYIFEND ON}
-{$IFEND}
-
 {$IF CompilerVersion < CompilerVersionDelphiXE8}
   {$IF (DEFINED(WIN32) OR DEFINED(CPUX86)) AND NOT DEFINED(CPU32BITS)}
     {$DEFINE CPU32BITS}
@@ -232,11 +232,9 @@ interface
 {$IFEND}
 
 // Assembler is only supplied for Windows targets. For other targets, PUREPASCAL must be defined.
-{$IFNDEF PUREPASCAL}
-  {$IFNDEF MSWINDOWS}
-    {$DEFINE PUREPASCAL}
-  {$ENDIF}
-{$ENDIF}
+{$IF not defined(PUREPASCAL) and not defined(MSWINDOWS)}
+  {$DEFINE PUREPASCAL}
+{$IFEND}
 
 const
 {$IFDEF PUREPASCAL}

Tests/BigDecimals/BigDecimalDevelopmentTests.dproj

@@ -113,6 +113,8 @@
         <DCCReference Include="..\..\Source\CompilerAndRTLVersions.pas"/>
         <None Include="BigDecimalTestData.inc"/>
         <None Include="..\..\Source\bases.inc"/>
+        <None Include="..\..\Source\Velthuis.BigIntegers.operators.hpp"/>
+        <None Include="..\..\Source\Velthuis.BigDecimals.operators.hpp"/>
         <BuildConfiguration Include="Release">
             <Key>Cfg_2</Key>
             <CfgParent>Base</CfgParent>

Tests/BigIntegers/BigIntegerDevelopmentTests.dproj

@@ -112,6 +112,7 @@
         <DCC_OutputXMLDocumentation>true</DCC_OutputXMLDocumentation>
         <DCC_UnitSearchPath>D:\Source\DropBox\Delphi\FastMM4-master;$(DCC_UnitSearchPath)</DCC_UnitSearchPath>
         <DCC_TypedAtParameter>true</DCC_TypedAtParameter>
+        <DCC_AdditionalSwitches>--symbol-report</DCC_AdditionalSwitches>
     </PropertyGroup>
     <PropertyGroup Condition="'$(Cfg_2)'!=''">
         <DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>