int CheckForULongOverflow()
{
switch (this.Kind)
{
case NumberKind.Real:
case NumberKind.Quad:
int status;
LLVMAPFloatRef apFloat = LLVMExt.APFloatFromAPFloat(APFloat, APFloatSemantics.IEEEquad, out status);
var comparisonMax = LLVMExt.APFloatCompare(apFloat, MaxULongValue);
var comparisonMin = LLVMExt.APFloatCompare(apFloat, MinULongValue);
LLVMExt.APFloatDispose(apFloat);
if (comparisonMax == 2)
{
return(1);
}
if (comparisonMin == 0)
{
return(-1);
}
return(0);
default:
throw new NotSupportedException();
}
}
public Number Duplicate()
{
var dup = new Number(dummy: string.Empty);
dup.State = this.State;
dup.Kind = this.Kind;
if (this.Value.Pointer.ToInt64() != 0)
{
dup.Value = Value;
}
if (this.APFloat.Pointer.ToInt64() != 0)
{
int status;
dup.APFloat = LLVMExt.APFloatFromAPFloat(this.APFloat, GetAPFloatSemantics(this.Kind), out status);
}
return(dup);
}
public Number Convert(NumberKind kind)
{
if (kind == this.Kind)
{
return(this);
}
if (this.HasErrors)
{
return(new Number(this.State, this.Kind));
}
if (this.Kind.IsInteger())
{
if (this.Kind.IsSigned())
{
var n = new Number(this.Int64Value, kind);
n.State |= this.State;
return(n);
}
else
{
var n = new Number(this.UInt64Value, kind);
n.State |= this.State;
return(n);
}
}
else
{
if (kind.IsFloat())
{
int status;
var apFloat = LLVMExt.APFloatFromAPFloat(this.APFloat, GetAPFloatSemantics(kind), out status);
return(new Number(dummy: string.Empty)
{
APFloat = apFloat,
State = this.State | (NumberState)status,
Kind = kind
});
}
else
{
if (this.Kind == NumberKind.Double)
{
var n = new Number(this.DoubleValue, kind);
n.State |= this.State;
return(n);
}
else if (this.Kind == NumberKind.Float)
{
var n = new Number(this.FloatValue, kind);
n.State |= this.State;
return(n);
}
else
{
if (kind.IsSigned())
{
var overflows = CheckForLongOverflow();
if (overflows == 1)
{
return(new Number(NumberState.Overflow, kind));
}
else if (overflows == -1)
{
return(new Number(NumberState.Underflow, kind));
}
else
{
var longValue = LLVM.ConstFPToSI(LLVMExt.APFloatToValue(APFloat), LLVM.Int64Type());
var longValue2 = LLVM.ConstIntGetSExtValue(longValue);
return(new Number(longValue2, kind));
}
}
else
{
var overflows = CheckForULongOverflow();
if (overflows == 1)
{
return(new Number(NumberState.Overflow, kind));
}
else if (overflows == -1)
{
return(new Number(NumberState.Underflow, kind));
}
else
{
var ulongValue = LLVM.ConstFPToUI(LLVMExt.APFloatToValue(APFloat), LLVM.Int64Type());
var ulongValue2 = LLVM.ConstIntGetZExtValue(ulongValue);
return(new Number(ulongValue2, kind));
}
}
}
}
}
}