Hello,

I am having a hard time to write a simple function that determines if a Double value is Int64:

function IsInt64(const aNumber: Double): Boolean;

I know about precision problems. I basically want to know if Round(aNumber) overflows.

In Delphi, Round() doesn't throw an exception if the value exceeds Int64 range, so it is safe to compare SameValue(aNumber, Round(aNumber)):

function OXmlIsInt64(const aNumber: Double): Boolean;
begin
     Result := not IsNan(aNumber) and not IsInfinite(aNumber) and
SameValue(Frac(aNumber), 0) and SameValue(aNumber, Round(aNumber));
end;

That's OK for me.

But in FPC, I get:
Project TestProject raised exception class 'External: FLT INVALID OPERATION' in Round().

Is there a chance to not throw this exception? I expect this problem so I don't want to do something like:

function OXmlIsInt64(const aNumber: Double): Boolean;
begin
   try
     Result := not IsNan(aNumber) and not IsInfinite(aNumber) and
SameValue(Frac(aNumber), 0) and SameValue(aNumber, Round(aNumber));
   except
     Result := False;
   end;
end;
I tried to switch overflow checks off:
{$OVERFLOWCHECKS OFF}

But obviously it doesn't help (it's a different exception).

----

I'd really like to get rid of the try-except block... It's the same with StrToInt() vs TryStrToInt(). IMO there should be a possibility to catch expected errors without exceptions.

Any ideas?

Thanks
Ondrej

AFAIK:
You need to use SetExceptionMask, I think the below example should do:

procedure DisableFloatExceptions;
begin
   if FloatExceptionLock = 0 then begin
     EM := GetExceptionMask;
     SetExceptionMask(EM + [exInvalidOp, exDenormalized, exZeroDivide,
exOverflow, exUnderflow, exPrecision]);
   end;
   inc(FloatExceptionLock);
end;
procedure EnableFloatExceptions;
begin
   dec(FloatExceptionLock);
   if FloatExceptionLock <= 0 then begin
     FloatExceptionLock := 0;
     ClearExceptions(False);
     SetExceptionMask(EM);
   end;
end;

The quickest way, I think, is to look at the exponent bits of the Double.  Though it returns a false negative for -(2^63):

function OXmlIsInt64(const aNumber: Double): Boolean;
var
   ExpMask: LongWord;
   DoubleBits: LongWord absolute aNumber;
begin
   ExpMask := (DoubleBits shr 52) and $7FF;
   Result := (ExpMask >= $3FF) and (ExpMask < $43F);
end;

I think that's correct - I haven't actually tested it though. Note it only works for the standard IEEE 754 Double.

Kit

Oh, minor error, the $43F constant is meant to be $43E.

Kit

Yes, that's it. And this is also the difference to Delphi. Thank you very much!

Ondrej