static int CheckForOverflow(ulong number, NumberKind numberKind) { switch (numberKind) { case NumberKind.Int8: return(number > (ulong)sbyte.MaxValue ? 1 : 0); case NumberKind.Int16: return(number > (ulong)short.MaxValue ? 1 : 0); case NumberKind.Int32: return(number > (ulong)int.MaxValue ? 1 : 0); case NumberKind.Int64: return(number > (ulong)long.MaxValue ? 1 : 0); case NumberKind.UInt8: return(number > (ulong)byte.MaxValue ? 1 : 0); case NumberKind.UInt16: return(number > (ulong)ushort.MaxValue ? 1 : 0); case NumberKind.UInt32: return(number > (ulong)uint.MaxValue ? 1 : 0); case NumberKind.UInt64: return(0); default: return(0); } }
public static bool IsNumberOfType(int number, NumberKind kind) { if (number == 0 && kind != NumberKind.Zero) return false; switch (kind) { case NumberKind.Zero: return number == 0; case NumberKind.Red: return _RedNumbers.Contains(number); case NumberKind.Black: return _BlackNumbers.Contains(number); case NumberKind.Odd: return number % 2 == 1; case NumberKind.Even: return number % 2 == 0; case NumberKind.To18: return number <= 18; case NumberKind.From19: return number >= 19; } return false; }
static int CheckForOverflow(double number, NumberKind numberKind) { switch (numberKind) { case NumberKind.Int8: return(number > sbyte.MaxValue ? 1 : (number < sbyte.MinValue ? -1 : 0)); case NumberKind.Int16: return(number > short.MaxValue ? 1 : (number < short.MinValue ? -1 : 0)); case NumberKind.Int32: return(number > int.MaxValue ? 1 : (number < int.MinValue ? -1 : 0)); case NumberKind.Int64: return(number > long.MaxValue ? 1 : (number < long.MinValue ? -1 : 0)); case NumberKind.UInt8: return(number > byte.MaxValue ? 1 : (number < 0 ? -1 : 0)); case NumberKind.UInt16: return(number > ushort.MaxValue ? 1 : (number < 0 ? -1 : 0)); case NumberKind.UInt32: return(number > uint.MaxValue ? 1 : (number < 0 ? -1 : 0)); case NumberKind.UInt64: return(number > ulong.MaxValue ? 1 : (number < 0 ? -1 : 0)); default: return(0); } }
public Number(ulong number, NumberKind numberKind) { this.Kind = numberKind; if (numberKind.IsInteger()) { var overflows = CheckForOverflow(number, numberKind); if (overflows == 1) { this.State = NumberState.Overflow; } else if (overflows == -1) { this.State = NumberState.Underflow; } if (!HasErrors) { this.Value = LLVM.ConstInt(GetLLVMType(), number, new LLVMBool(0)); } } else { this.APFloat = LLVMExt.APFloatZero(GetAPFloatSemantics(this.Kind)); this.State |= (NumberState)LLVMExt.APFloatFromString(this.APFloat, number.ToString(CultureInfo.InvariantCulture), RoundingMode); } }
public Number(string number, NumberKind numberKind) { if (number == null) { throw new ArgumentNullException(nameof(number)); } this.Kind = numberKind; if (numberKind.IsInteger()) { this.State = CheckIntegerString(number, numberKind); if (!this.HasErrors) { this.Value = LLVM.ConstIntOfString(LLVM.Int128Type(), number, 10); } } else { this.State = CheckFloatString(number); if (!this.HasErrors) { this.APFloat = LLVMExt.APFloatZero(GetAPFloatSemantics(this.Kind)); this.State |= (NumberState)LLVMExt.APFloatFromString(this.APFloat, number, RoundingMode); } } }
public async Task <NumberKind> AddNumberKind(NumberKind c) { var result = await peopleDbContext.NumberKinds.AddAsync(c); await peopleDbContext.SaveChangesAsync(); return(result.Entity); }
internal static ExpressionValueKind Convert(NumberKind kind) { switch (kind) { case NumberKind.Integer: return ExpressionValueKind.Integer; case NumberKind.Long: return ExpressionValueKind.Long; case NumberKind.Single: return ExpressionValueKind.Single; case NumberKind.Double: return ExpressionValueKind.Double; default: throw Contract.CreateInvalidEnumValueException(kind); } }
static NumberState CheckIntegerString(string number, NumberKind numberKind) { if (!IntegerRegex.IsMatch(number)) { return(NumberState.Invalid); } var isNegative = number.StartsWith("-", StringComparison.InvariantCultureIgnoreCase); var overflows = CheckForOverflow(number, numberKind); return(overflows ? (isNegative ? NumberState.Underflow : NumberState.Overflow) : NumberState.Ok); }
NumberState CheckForOpOverflow(NumberKind opKind, LLVMValueRef result) { if (opKind.IsSigned()) { var lessThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntSLT, result, MinLongLLVMValue).ConstIntGetZExtValue() == 1; if (lessThan) { return(NumberState.Underflow); } var greatherThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntSGT, result, MaxLongLLVMValue).ConstIntGetZExtValue() == 1; if (greatherThan) { return(NumberState.Overflow); } var overflows = CheckForOverflow(result.ConstIntGetSExtValue(), opKind); if (overflows == 1) { return(NumberState.Overflow); } else if (overflows == -1) { return(NumberState.Underflow); } else { return(NumberState.Ok); } } else { var greatherThan = LLVM.ConstICmp(LLVMIntPredicate.LLVMIntUGT, result, MaxULongLLVMValue).ConstIntGetZExtValue() == 1; if (greatherThan) { return(NumberState.Overflow); } var overflows = CheckForOverflow(result.ConstIntGetZExtValue(), opKind); if (overflows == 1) { return(NumberState.Overflow); } else if (overflows == -1) { return(NumberState.Underflow); } else { return(NumberState.Ok); } } }
public NumberSemantics( NumberKind DefaultKind = NumberKind.Int32, FloatSemantics LongDoubleSemantics = FloatSemantics.X87DoubleExtended, FloatSemantics QuadSemantics = FloatSemantics.IEEEQuad) { if (!DefaultKind.IsInteger()) { throw new ArgumentException("DefaultKind must be an integer", nameof(DefaultKind)); } this.DefaultKind = DefaultKind; this.LongDoubleSemantics = LongDoubleSemantics; this.QuadSemantics = QuadSemantics; }
private NumberKind ScanOptionalIntegerSuffix() { NumberKind unsuffixedInteger = NumberKind.UnsuffixedInteger; char ch2 = this.CurrentChar(); if (ch2 <= 'U') { switch (ch2) { case 'L': goto Label_0028; case 'U': goto Label_0048; } return(unsuffixedInteger); } switch (ch2) { case 'l': break; case 'u': goto Label_0048; default: return(unsuffixedInteger); } Label_0028: switch (this.NextChar()) { case 'u': case 'U': unsuffixedInteger = NumberKind.Unsigned | NumberKind.Long; this.NextChar(); return(unsuffixedInteger); default: return(NumberKind.Long); } Label_0048: switch (this.NextChar()) { case 'l': case 'L': unsuffixedInteger = NumberKind.Unsigned | NumberKind.Long; this.NextChar(); return(unsuffixedInteger); } return(NumberKind.Unsigned); }
public async Task <NumberKind> UpdateNumberKind(NumberKind c) { var result = await peopleDbContext.NumberKinds .FirstOrDefaultAsync(e => e.NumberKindId == c.NumberKindId); if (result != null) { result.Label = c.Label; await peopleDbContext.SaveChangesAsync(); return(result); } return(null); }
private NumberKind ScanExponent(StringBuilder buffer) { char ch = CurrentChar(); if (ch == '-' || ch == '+') { buffer.Append(ch); ch = NextChar(); } if (!char.IsDigit(ch)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidExponentDigit, ch); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidExponentDigit, message, currentPosition); } do { buffer.Append(ch); ch = NextChar(); } while (char.IsDigit(ch)); NumberKind numberKind = NumberKind.Double; switch (ch) { case 'd': case 'D': numberKind = NumberKind.Double; NextChar(); break; case 'f': case 'F': numberKind = NumberKind.Float; NextChar(); break; case 'm': case 'M': numberKind = NumberKind.Decimal; NextChar(); break; } return(numberKind); }
static bool CheckForOverflow(string number, NumberKind numberKind) { try { switch (numberKind) { case NumberKind.Int8: sbyte.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.Int16: short.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.Int32: int.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.Int64: long.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.UInt8: byte.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.UInt16: ushort.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.UInt32: uint.Parse(number, CultureInfo.InvariantCulture); break; case NumberKind.UInt64: ulong.Parse(number, CultureInfo.InvariantCulture); break; default: throw new NotSupportedException(); } return(false); } catch { return(true); } }
public static bool IsInteger(this NumberKind kind) { switch (kind) { case NumberKind.Int8: case NumberKind.Int16: case NumberKind.Int32: case NumberKind.Int64: case NumberKind.UInt8: case NumberKind.UInt16: case NumberKind.UInt32: case NumberKind.UInt64: return(true); default: return(false); } }
public static bool IsSigned(this NumberKind kind) { switch (kind) { case NumberKind.Int8: case NumberKind.Int16: case NumberKind.Int32: case NumberKind.Int64: case NumberKind.Float: case NumberKind.Double: case NumberKind.Real: case NumberKind.Quad: return(true); default: return(false); } }
private NumberKind ScanFraction(StringBuilder buffer) { char ch = CurrentChar(); while (char.IsDigit(ch)) { buffer.Append(ch); ch = NextChar(); } NumberKind numberKind = NumberKind.Double; switch (ch) { case 'e': case 'E': buffer.Append('E'); NextChar(); numberKind = ScanExponent(buffer); break; case 'd': case 'D': numberKind = NumberKind.Double; NextChar(); break; case 'f': case 'F': numberKind = NumberKind.Float; NextChar(); break; case 'm': case 'M': numberKind = NumberKind.Decimal; NextChar(); break; } return(numberKind); }
private NumberKind ScanOptionalIntegerSuffix() { NumberKind numberKind = NumberKind.UnsuffixedInteger; char ch = CurrentChar(); switch (ch) { case 'l': case 'L': ch = NextChar(); // eat the 'L' if (ch == 'u' || ch == 'U') { // "LU" is a ulong. numberKind = NumberKind.Long | NumberKind.Unsigned; NextChar(); // eat the 'U' } else { // "L" is a long numberKind = NumberKind.Long; } break; case 'u': case 'U': ch = NextChar(); // Eat the 'U' if (ch == 'l' || ch == 'L') { // "UL" is a ulong. numberKind = NumberKind.Long | NumberKind.Unsigned; NextChar(); // eat the 'L' } else { numberKind = NumberKind.Unsigned; } break; } return(numberKind); }
public static NumberKind Signed(this NumberKind kind) { switch (kind) { case NumberKind.UInt8: return(NumberKind.Int8); case NumberKind.UInt16: return(NumberKind.Int16); case NumberKind.UInt32: return(NumberKind.Int32); case NumberKind.UInt64: return(NumberKind.Int64); default: return(kind); } }
static APFloatSemantics GetAPFloatSemantics(NumberKind kind) { switch (kind) { case NumberKind.Float: return(APFloatSemantics.IEEEsingle); case NumberKind.Double: return(APFloatSemantics.IEEEdouble); case NumberKind.Real: case NumberKind.Quad: switch (kind == NumberKind.Real ? Semantics.LongDoubleSemantics : Semantics.QuadSemantics) { case FloatSemantics.IEEEHalf: return(APFloatSemantics.IEEEhalf); case FloatSemantics.IEEESingle: return(APFloatSemantics.IEEEsingle); case FloatSemantics.IEEEDouble: return(APFloatSemantics.IEEEdouble); case FloatSemantics.IEEEQuad: return(APFloatSemantics.IEEEquad); case FloatSemantics.PPCDoubleDouble: return(APFloatSemantics.PPCDoubleDouble); case FloatSemantics.X87DoubleExtended: return(APFloatSemantics.X87DoubleExtended); default: throw new NotSupportedException(); } default: throw new NotSupportedException(); } }
public static NumberKind Unsigned(this NumberKind kind) { switch (kind) { case NumberKind.Int8: case NumberKind.UInt8: return(NumberKind.UInt8); case NumberKind.Int16: case NumberKind.UInt16: return(NumberKind.UInt16); case NumberKind.Int32: case NumberKind.UInt32: return(NumberKind.UInt32); case NumberKind.Int64: case NumberKind.UInt64: return(NumberKind.UInt64); default: throw new NotSupportedException("doesn't have an unsigned counterpart"); } }
public Number(double number, NumberKind numberKind) { this.Kind = numberKind; if (numberKind.IsInteger()) { var overflows = CheckForOverflow(number, numberKind); if (overflows == 1) { this.State = NumberState.Overflow; } else if (overflows == -1) { this.State = NumberState.Underflow; } if (!HasErrors) { this.Value = LLVM.ConstReal(LLVM.DoubleType(), number); if (numberKind.IsSigned()) { this.Value = LLVM.ConstFPToSI(this.Value, GetLLVMType()); } else { this.Value = LLVM.ConstFPToUI(this.Value, GetLLVMType()); } } } else { int state; this.APFloat = LLVMExt.APFloatFromDouble(number, GetAPFloatSemantics(this.Kind), out state); this.State |= (NumberState)state; } }
static NumberKind GetBestFloatKind(NumberKind k1, NumberKind k2) { var kSize = k1.BitSize(Semantics); if (kSize == 64) { return(NumberKind.Double); } else if (kSize == 32) { return(NumberKind.Float); } else { if (k1 == NumberKind.Real || k2 == NumberKind.Real) { return(NumberKind.Real); } else { return(NumberKind.Quad); } } }
public NumberType(NumberKind numberKind, int bitSize) { NumberKind = numberKind; BitSize = bitSize; }
// Output Setters private void outputSetBin(object sender, RoutedEventArgs e) { outputKind = NumberKind.Binary; }
private TokenID ScanHexNumber() { char ch = CurrentChar(); int hValue = HexValue(ch); if (hValue < 0) { string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidHexDigit, ch); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidHexDigit, message, currentPosition); } int length = 1; ulong value = (ulong)hValue; ch = NextChar(); hValue = HexValue(ch); while (hValue >= 0) { ++length; value = (value * 16) + (ulong)hValue; ch = NextChar(); hValue = HexValue(ch); } if (length > sizeof(ulong) * 2) { // We had overflow. string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, string.Empty); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidIntegerLiteral, message, tokenStartPosition); } TokenID token = TokenID.IntegerLiteral; NumberKind numberKind = ScanOptionalIntegerSuffix(); switch (numberKind) { case NumberKind.UnsuffixedInteger: // It's an "int" if it fits, else it's a "long" if it fits, else it's a "ulong". if (value > long.MaxValue) // too big for long, keep it ulong { tokenValue = value; } else if (value <= int.MaxValue) // fits into an int { tokenValue = (int)value; } else { tokenValue = (long)value; // it's a long } break; case NumberKind.Long: tokenValue = (long)value; break; case NumberKind.Unsigned: // It's a "uint" if it fits, else its a "ulong" if (value <= uint.MaxValue) { tokenValue = (uint)value; } else { tokenValue = value; } break; case NumberKind.Unsigned | NumberKind.Long: tokenValue = value; break; } return(token); }
private void outputSetHex(object sender, RoutedEventArgs e) { outputKind = NumberKind.Hexa; }
private void outputSetInt(object sender, RoutedEventArgs e) { outputKind = NumberKind.Int32; }
private TokenID ScanDecimal() { NumberKind numberKind = NumberKind.UnsuffixedInteger; // Start by assuming it's an "int" constant. StringBuilder buffer = new StringBuilder(); char ch = CurrentChar(); while (char.IsDigit(ch)) { buffer.Append(ch); ch = NextChar(); } switch (ch) { case '.': numberKind = NumberKind.Double; // It's a double or float. buffer.Append('.'); NextChar(); // eat the '.' numberKind = ScanFraction(buffer); break; case 'e': case 'E': buffer.Append('e'); NextChar(); // eat the 'e' numberKind = ScanExponent(buffer); break; case 'f': case 'F': numberKind = NumberKind.Float; NextChar(); // eat the 'f' break; case 'd': case 'D': numberKind = NumberKind.Double; NextChar(); // eat the 'd' break; case 'm': case 'M': numberKind = NumberKind.Decimal; NextChar(); // eat the 'm' break; default: numberKind = ScanOptionalIntegerSuffix(); break; } string message; TokenID token; string numberString = buffer.ToString(); if (numberKind == NumberKind.Float) { token = TokenID.FloatLiteral; try { tokenValue = float.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture); } catch (Exception exception) { message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, exception.Message); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition); } } else if (numberKind == NumberKind.Double) { token = TokenID.FloatLiteral; try { tokenValue = double.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture); } catch (Exception exception) { message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, exception.Message); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition); } } else if (numberKind == NumberKind.Decimal) { token = TokenID.DecimalLiteral; try { tokenValue = decimal.Parse(numberString, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture); } catch (Exception exception) { message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidDecimalConstant, exception.Message); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidRealLiteral, message, tokenStartPosition); } } else { token = TokenID.IntegerLiteral; ulong value = 0; try { value = ulong.Parse(numberString, CultureInfo.InvariantCulture); } catch (Exception exception) { message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, exception.Message); throw new RuleSyntaxException(ErrorNumbers.Error_InvalidIntegerLiteral, message, tokenStartPosition); } switch (numberKind) { case NumberKind.UnsuffixedInteger: // It's an "int" if it fits, else it's a "long" if it fits, else it's a "ulong". if (value > long.MaxValue) // too big for long, keep it ulong { tokenValue = value; } else if (value <= int.MaxValue) // fits into an int { tokenValue = (int)value; } else { tokenValue = (long)value; // it's a long } break; case NumberKind.Long: tokenValue = (long)value; break; case NumberKind.Unsigned: // It's a "uint" if it fits, else its a "ulong" if (value <= uint.MaxValue) { tokenValue = (uint)value; } else { tokenValue = value; } break; case NumberKind.Unsigned | NumberKind.Long: tokenValue = value; break; } } return(token); }
public void AddNumberKindBalancePoint(NumberKind numKind, int advantage) { int newPointY = (MainWindow.NumberBalancesCanvasHeight / 2) - advantage; if (numKind == NumberKind.Red) { UpdateNumberBalances(RedBlackBalancesLine, newPointY); } else if (numKind == NumberKind.Even) { UpdateNumberBalances(EvenOddBalancesLine, newPointY); } else if (numKind == NumberKind.To18) { UpdateNumberBalances(To18From19BalancesLine, newPointY); } }
private NumberKind ScanFraction(StringBuilder buffer) { char c = this.CurrentChar(); while (char.IsDigit(c)) { buffer.Append(c); c = this.NextChar(); } NumberKind kind = NumberKind.Double; char ch2 = c; if (ch2 <= 'M') { switch (ch2) { case 'D': goto Label_007B; case 'E': goto Label_0061; case 'F': goto Label_0086; case 'M': goto Label_0092; } return(kind); } switch (ch2) { case 'd': goto Label_007B; case 'e': break; case 'f': goto Label_0086; case 'm': goto Label_0092; default: return(kind); } Label_0061: buffer.Append('E'); this.NextChar(); return(this.ScanExponent(buffer)); Label_007B: kind = NumberKind.Double; this.NextChar(); return(kind); Label_0086: kind = NumberKind.Float; this.NextChar(); return(kind); Label_0092: kind = NumberKind.Decimal; this.NextChar(); return(kind); }
private NumberKind ScanExponent(StringBuilder buffer) { char ch = this.CurrentChar(); switch (ch) { case '-': case '+': buffer.Append(ch); ch = this.NextChar(); break; } if (!char.IsDigit(ch)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidExponentDigit, new object[] { ch }); throw new RuleSyntaxException(0x17e, message, this.currentPosition); } do { buffer.Append(ch); ch = this.NextChar(); }while (char.IsDigit(ch)); NumberKind kind = NumberKind.Double; char ch2 = ch; if (ch2 <= 'M') { switch (ch2) { case 'D': goto Label_00B9; case 'E': return(kind); case 'F': goto Label_00C4; case 'M': goto Label_00D0; } return(kind); } switch (ch2) { case 'd': break; case 'e': return(kind); case 'f': goto Label_00C4; case 'm': goto Label_00D0; default: return(kind); } Label_00B9: kind = NumberKind.Double; this.NextChar(); return(kind); Label_00C4: kind = NumberKind.Float; this.NextChar(); return(kind); Label_00D0: kind = NumberKind.Decimal; this.NextChar(); return(kind); }
private TokenID ScanDecimal() { string str; TokenID integerLiteral; NumberKind unsuffixedInteger = NumberKind.UnsuffixedInteger; StringBuilder buffer = new StringBuilder(); char c = this.CurrentChar(); while (char.IsDigit(c)) { buffer.Append(c); c = this.NextChar(); } switch (c) { case 'd': case 'D': unsuffixedInteger = NumberKind.Double; this.NextChar(); break; case 'e': case 'E': buffer.Append('e'); this.NextChar(); unsuffixedInteger = this.ScanExponent(buffer); break; case 'f': case 'F': unsuffixedInteger = NumberKind.Float; this.NextChar(); break; case 'm': case 'M': unsuffixedInteger = NumberKind.Decimal; this.NextChar(); break; case '.': unsuffixedInteger = NumberKind.Double; buffer.Append('.'); this.NextChar(); unsuffixedInteger = this.ScanFraction(buffer); break; default: unsuffixedInteger = this.ScanOptionalIntegerSuffix(); break; } string s = buffer.ToString(); switch (unsuffixedInteger) { case NumberKind.Float: integerLiteral = TokenID.FloatLiteral; try { this.tokenValue = float.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture); return(integerLiteral); } catch (Exception exception) { str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, new object[] { exception.Message }); throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition); } break; case NumberKind.Double: integerLiteral = TokenID.FloatLiteral; try { this.tokenValue = double.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture); return(integerLiteral); } catch (Exception exception2) { str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidFloatingPointConstant, new object[] { exception2.Message }); throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition); } break; case NumberKind.Decimal: integerLiteral = TokenID.DecimalLiteral; try { this.tokenValue = decimal.Parse(s, NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture); return(integerLiteral); } catch (Exception exception3) { str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidDecimalConstant, new object[] { exception3.Message }); throw new RuleSyntaxException(0x1a7, str, this.tokenStartPosition); } break; } integerLiteral = TokenID.IntegerLiteral; ulong num = 0L; try { num = ulong.Parse(s, CultureInfo.InvariantCulture); } catch (Exception exception4) { str = string.Format(CultureInfo.CurrentCulture, Messages.Parser_InvalidIntegerConstant, new object[] { exception4.Message }); throw new RuleSyntaxException(0x192, str, this.tokenStartPosition); } switch (unsuffixedInteger) { case NumberKind.UnsuffixedInteger: if (num <= 0x7fffffffffffffffL) { if (num <= 0x7fffffffL) { this.tokenValue = (int)num; return(integerLiteral); } this.tokenValue = (long)num; return(integerLiteral); } this.tokenValue = num; return(integerLiteral); case NumberKind.Long: this.tokenValue = (long)num; return(integerLiteral); case (NumberKind.Long | NumberKind.UnsuffixedInteger): case (NumberKind.Unsigned | NumberKind.UnsuffixedInteger): return(integerLiteral); case NumberKind.Unsigned: if (num > 0xffffffffL) { this.tokenValue = num; return(integerLiteral); } this.tokenValue = (uint)num; return(integerLiteral); case (NumberKind.Unsigned | NumberKind.Long): this.tokenValue = num; return(integerLiteral); } return(integerLiteral); }
public Number(double d) { Value = d; Kind = NumberKind.Double; }
public Number(float f) { Value = f; Kind = NumberKind.Single; }