?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-07 Jb Evain <jbevain@novell.com>
[mcs.git] / class / corlib / System / Int64.cs
blobbb06bae7a6431508ec23fbb88cc3afe517a6f3fb
1 //
2 // System.Int64.cs
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 //
7 // (C) Ximian, Inc. http://www.ximian.com
8 //
9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System.Globalization;
32 using System.Threading;
33
34 namespace System {
35
36 [Serializable]
37 [System.Runtime.InteropServices.ComVisible (true)]
38 public struct Int64 : IFormattable, IConvertible, IComparable, IComparable<Int64>, IEquatable <Int64>
39 {
40
41 public const long MaxValue = 0x7fffffffffffffff;
42 public const long MinValue = -9223372036854775808;
43
44 internal long m_value;
45
46 public int CompareTo (object value)
47 {
48 if (value == null)
49 return 1;
50
51 if (!(value is System.Int64))
52 throw new ArgumentException (Locale.GetText ("Value is not a System.Int64"));
53
54 long lValue = (long) value;
55
56 if (m_value == lValue)
57 return 0;
58
59 return (m_value < lValue) ? -1 : 1;
60 }
61
62 public override bool Equals (object obj)
63 {
64 if (!(obj is System.Int64))
65 return false;
66
67 return ((long) obj) == m_value;
68 }
69
70 public override int GetHashCode ()
71 {
72 return (int)(m_value & 0xffffffff) ^ (int)(m_value >> 32);
73 }
74
75 public int CompareTo (long value)
76 {
77 if (m_value == value)
78 return 0;
79 if (m_value > value)
80 return 1;
81 else
82 return -1;
83 }
84
85 public bool Equals (long obj)
86 {
87 return obj == m_value;
88 }
89
90 internal static bool Parse (string s, bool tryParse, out long result, out Exception exc)
91 {
92 long val = 0;
93 int len;
94 int i;
95 int sign = 1;
96 bool digits_seen = false;
97
98 result = 0;
99 exc = null;
100
101 if (s == null) {
102 if (!tryParse)
103 exc = new ArgumentNullException ("s");
104 return false;
105 }
106
107 len = s.Length;
108
109 char c;
110 for (i = 0; i < len; i++){
111 c = s [i];
112 if (!Char.IsWhiteSpace (c))
113 break;
114 }
115
116 if (i == len) {
117 if (!tryParse)
118 exc = Int32.GetFormatException ();
119 return false;
120 }
121
122 c = s [i];
123 if (c == '+')
124 i++;
125 else if (c == '-'){
126 sign = -1;
127 i++;
128 }
129
130 for (; i < len; i++){
131 c = s [i];
132
133 if (c >= '0' && c <= '9'){
134 byte d = (byte) (c - '0');
135
136 if (val > (MaxValue/10))
137 goto overflow;
138
139 if (val == (MaxValue/10)){
140 if ((d > (MaxValue % 10)) && (sign == 1 || (d > ((MaxValue % 10) + 1))))
141 goto overflow;
142 if (sign == -1)
143 val = (val * sign * 10) - d;
144 else
145 val = (val * 10) + d;
146
147 if (Int32.ProcessTrailingWhitespace (tryParse, s, i + 1, ref exc)){
148 result = val;
149 return true;
150 }
151 goto overflow;
152 } else
153 val = val * 10 + d;
154
155
156 digits_seen = true;
157 } else if (!Int32.ProcessTrailingWhitespace (tryParse, s, i, ref exc))
158 return false;
159
160 }
161 if (!digits_seen) {
162 if (!tryParse)
163 exc = Int32.GetFormatException ();
164 return false;
165 }
166
167 if (sign == -1)
168 result = val * sign;
169 else
170 result = val;
171
172 return true;
173
174 overflow:
175 if (!tryParse)
176 exc = new OverflowException ("Value is too large");
177 return false;
178 }
179
180 public static long Parse (string s, IFormatProvider provider)
181 {
182 return Parse (s, NumberStyles.Integer, provider);
183 }
184
185 public static long Parse (string s, NumberStyles style)
186 {
187 return Parse (s, style, null);
188 }
189
190 internal static bool Parse (string s, NumberStyles style, IFormatProvider fp, bool tryParse, out long result, out Exception exc)
191 {
192 result = 0;
193 exc = null;
194
195 if (s == null) {
196 if (!tryParse)
197 exc = new ArgumentNullException ("s");
198 return false;
199 }
200
201 if (s.Length == 0) {
202 if (!tryParse)
203 exc = new FormatException ("Input string was not " +
204 "in the correct format: s.Length==0.");
205 return false;
206 }
207
208 NumberFormatInfo nfi = null;
209 if (fp != null) {
210 Type typeNFI = typeof (System.Globalization.NumberFormatInfo);
211 nfi = (NumberFormatInfo) fp.GetFormat (typeNFI);
212 }
213 if (nfi == null)
214 nfi = Thread.CurrentThread.CurrentCulture.NumberFormat;
215
216 if (!Int32.CheckStyle (style, tryParse, ref exc))
217 return false;
218
219 bool AllowCurrencySymbol = (style & NumberStyles.AllowCurrencySymbol) != 0;
220 bool AllowHexSpecifier = (style & NumberStyles.AllowHexSpecifier) != 0;
221 bool AllowThousands = (style & NumberStyles.AllowThousands) != 0;
222 bool AllowDecimalPoint = (style & NumberStyles.AllowDecimalPoint) != 0;
223 bool AllowParentheses = (style & NumberStyles.AllowParentheses) != 0;
224 bool AllowTrailingSign = (style & NumberStyles.AllowTrailingSign) != 0;
225 bool AllowLeadingSign = (style & NumberStyles.AllowLeadingSign) != 0;
226 bool AllowTrailingWhite = (style & NumberStyles.AllowTrailingWhite) != 0;
227 bool AllowLeadingWhite = (style & NumberStyles.AllowLeadingWhite) != 0;
228
229 int pos = 0;
230
231 if (AllowLeadingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
232 return false;
233
234 bool foundOpenParentheses = false;
235 bool negative = false;
236 bool foundSign = false;
237 bool foundCurrency = false;
238
239 // Pre-number stuff
240 if (AllowParentheses && s [pos] == '(') {
241 foundOpenParentheses = true;
242 foundSign = true;
243 negative = true; // MS always make the number negative when there parentheses
244 // even when NumberFormatInfo.NumberNegativePattern != 0!!!
245 pos++;
246 if (AllowLeadingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
247 return false;
248
249 if (s.Substring (pos, nfi.NegativeSign.Length) == nfi.NegativeSign) {
250 if (!tryParse)
251 exc = new FormatException ("Input string was not in the correct " +
252 "format: Has Negative Sign.");
253 return false;
254 }
255 if (s.Substring (pos, nfi.PositiveSign.Length) == nfi.PositiveSign) {
256 if (!tryParse)
257 exc = new FormatException ("Input string was not in the correct " +
258 "format: Has Positive Sign.");
259 return false;
260 }
261 }
262
263 if (AllowLeadingSign && !foundSign) {
264 // Sign + Currency
265 Int32.FindSign (ref pos, s, nfi, ref foundSign, ref negative);
266 if (foundSign) {
267 if (AllowLeadingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
268 return false;
269 if (AllowCurrencySymbol) {
270 Int32.FindCurrency (ref pos, s, nfi,
271 ref foundCurrency);
272 if (foundCurrency && AllowLeadingWhite &&
273 !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
274 return false;
275 }
276 }
277 }
278
279 if (AllowCurrencySymbol && !foundCurrency) {
280 // Currency + sign
281 Int32.FindCurrency (ref pos, s, nfi, ref foundCurrency);
282 if (foundCurrency) {
283 if (AllowLeadingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
284 return false;
285 if (foundCurrency) {
286 if (!foundSign && AllowLeadingSign) {
287 Int32.FindSign (ref pos, s, nfi, ref foundSign,
288 ref negative);
289 if (foundSign && AllowLeadingWhite &&
290 !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
291 return false;
292 }
293 }
294 }
295 }
296
297 long number = 0;
298 int nDigits = 0;
299 bool decimalPointFound = false;
300 int digitValue;
301 char hexDigit;
302
303 // Number stuff
304 do {
305
306 if (!Int32.ValidDigit (s [pos], AllowHexSpecifier)) {
307 if (AllowThousands &&
308 (Int32.FindOther (ref pos, s, nfi.NumberGroupSeparator)
309 || Int32.FindOther (ref pos, s, nfi.CurrencyGroupSeparator)))
310 continue;
311 else
312 if (!decimalPointFound && AllowDecimalPoint &&
313 (Int32.FindOther (ref pos, s, nfi.NumberDecimalSeparator)
314 || Int32.FindOther (ref pos, s, nfi.CurrencyDecimalSeparator))) {
315 decimalPointFound = true;
316 continue;
317 }
318
319 break;
320 }
321 else if (AllowHexSpecifier) {
322 nDigits++;
323 hexDigit = s [pos++];
324 if (Char.IsDigit (hexDigit))
325 digitValue = (int) (hexDigit - '0');
326 else if (Char.IsLower (hexDigit))
327 digitValue = (int) (hexDigit - 'a' + 10);
328 else
329 digitValue = (int) (hexDigit - 'A' + 10);
330
331 ulong unumber = (ulong)number;
332
333 // IMPROVME: We could avoid catching OverflowException
334 try {
335 number = (long)checked(unumber * 16ul + (ulong)digitValue);
336 } catch (OverflowException e){
337 if (!tryParse)
338 exc = e;
339 return false;
340 }
341 }
342 else if (decimalPointFound) {
343 nDigits++;
344 // Allows decimal point as long as it's only
345 // followed by zeroes.
346 if (s [pos++] != '0') {
347 if (!tryParse)
348 exc = new OverflowException ("Value too large or too " +
349 "small.");
350 return false;
351 }
352 }
353 else {
354 nDigits++;
355
356 try {
357 // Calculations done as negative
358 // (abs (MinValue) > abs (MaxValue))
359 number = checked (
360 number * 10 -
361 (long) (s [pos++] - '0')
362 );
363 } catch (OverflowException) {
364 if (!tryParse)
365 exc = new OverflowException ("Value too large or too " +
366 "small.");
367 return false;
368 }
369 }
370 } while (pos < s.Length);
371
372 // Post number stuff
373 if (nDigits == 0) {
374 if (!tryParse)
375 exc = new FormatException ("Input string was not in the correct format: nDigits == 0.");
376 return false;
377 }
378
379 if (AllowTrailingSign && !foundSign) {
380 // Sign + Currency
381 Int32.FindSign (ref pos, s, nfi, ref foundSign, ref negative);
382 if (foundSign) {
383 if (AllowTrailingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
384 return false;
385 if (AllowCurrencySymbol)
386 Int32.FindCurrency (ref pos, s, nfi,
387 ref foundCurrency);
388 }
389 }
390
391 if (AllowCurrencySymbol && !foundCurrency) {
392 // Currency + sign
393 if (nfi.CurrencyPositivePattern == 3 && s[pos++] != ' ')
394 if (tryParse)
395 return false;
396 else
397 throw new FormatException ("Input string was not in the correct format: no space between number and currency symbol.");
398
399 Int32.FindCurrency (ref pos, s, nfi, ref foundCurrency);
400 if (foundCurrency && pos < s.Length) {
401 if (AllowTrailingWhite && !Int32.JumpOverWhite (ref pos, s, true, tryParse, ref exc))
402 return false;
403 if (!foundSign && AllowTrailingSign)
404 Int32.FindSign (ref pos, s, nfi, ref foundSign,
405 ref negative);
406 }
407 }
408
409 if (AllowTrailingWhite && pos < s.Length && !Int32.JumpOverWhite (ref pos, s, false, tryParse, ref exc))
410 return false;
411
412 if (foundOpenParentheses) {
413 if (pos >= s.Length || s [pos++] != ')') {
414 if (!tryParse)
415 exc = new FormatException ("Input string was not in the correct " +
416 "format: No room for close parens.");
417 return false;
418 }
419 if (AllowTrailingWhite && pos < s.Length && !Int32.JumpOverWhite (ref pos, s, false, tryParse, ref exc))
420 return false;
421 }
422
423 if (pos < s.Length && s [pos] != '\u0000') {
424 if (!tryParse)
425 exc = new FormatException ("Input string was not in the correct format: Did not parse entire string. pos = "
426 + pos + " s.Length = " + s.Length);
427 return false;
428 }
429
430
431 if (!negative && !AllowHexSpecifier){
432 try {
433 number = checked (-number);
434 } catch (OverflowException e){
435 if (!tryParse)
436 exc = e;
437 return false;
438 }
439 }
440
441 result = number;
442 return true;
443 }
444
445 public static long Parse (string s)
446 {
447 Exception exc;
448 long res;
449
450 if (!Parse (s, false, out res, out exc))
451 throw exc;
452
453 return res;
454 }
455
456 public static long Parse (string s, NumberStyles style, IFormatProvider provider)
457 {
458 Exception exc;
459 long res;
460
461 if (!Parse (s, style, provider, false, out res, out exc))
462 throw exc;
463
464 return res;
465 }
466
467 public static bool TryParse (string s, out long result)
468 {
469 Exception exc;
470 if (!Parse (s, true, out result, out exc)) {
471 result = 0;
472 return false;
473 }
474
475 return true;
476 }
477
478 public static bool TryParse (string s, NumberStyles style, IFormatProvider provider, out long result)
479 {
480 Exception exc;
481 if (!Parse (s, style, provider, true, out result, out exc)) {
482 result = 0;
483 return false;
484 }
485
486 return true;
487 }
488
489 public override string ToString ()
490 {
491 return NumberFormatter.NumberToString (m_value, null);
492 }
493
494 public string ToString (IFormatProvider provider)
495 {
496 return NumberFormatter.NumberToString (m_value, provider);
497 }
498
499 public string ToString (string format)
500 {
501 return ToString (format, null);
502 }
503
504 public string ToString (string format, IFormatProvider provider)
505 {
506 return NumberFormatter.NumberToString (format, m_value, provider);
507 }
508
509 // =========== IConvertible Methods =========== //
510
511 public TypeCode GetTypeCode ()
512 {
513 return TypeCode.Int64;
514 }
515
516 bool IConvertible.ToBoolean (IFormatProvider provider)
517 {
518 return System.Convert.ToBoolean (m_value);
519 }
520
521 byte IConvertible.ToByte (IFormatProvider provider)
522 {
523 return System.Convert.ToByte (m_value);
524 }
525
526 char IConvertible.ToChar (IFormatProvider provider)
527 {
528 return System.Convert.ToChar (m_value);
529 }
530
531 DateTime IConvertible.ToDateTime (IFormatProvider provider)
532 {
533 return System.Convert.ToDateTime (m_value);
534 }
535
536 decimal IConvertible.ToDecimal (IFormatProvider provider)
537 {
538 return System.Convert.ToDecimal (m_value);
539 }
540
541 double IConvertible.ToDouble (IFormatProvider provider)
542 {
543 return System.Convert.ToDouble (m_value);
544 }
545
546 short IConvertible.ToInt16 (IFormatProvider provider)
547 {
548 return System.Convert.ToInt16 (m_value);
549 }
550
551 int IConvertible.ToInt32 (IFormatProvider provider)
552 {
553 return System.Convert.ToInt32 (m_value);
554 }
555
556 long IConvertible.ToInt64 (IFormatProvider provider)
557 {
558 return System.Convert.ToInt64 (m_value);
559 }
560
561 sbyte IConvertible.ToSByte (IFormatProvider provider)
562 {
563 return System.Convert.ToSByte (m_value);
564 }
565
566 float IConvertible.ToSingle (IFormatProvider provider)
567 {
568 return System.Convert.ToSingle (m_value);
569 }
570
571 object IConvertible.ToType (Type targetType, IFormatProvider provider)
572 {
573 if (targetType == null)
574 throw new ArgumentNullException ("targetType");
575 return System.Convert.ToType (m_value, targetType, provider, false);
576 }
577
578 ushort IConvertible.ToUInt16 (IFormatProvider provider)
579 {
580 return System.Convert.ToUInt16 (m_value);
581 }
582
583 uint IConvertible.ToUInt32 (IFormatProvider provider)
584 {
585 return System.Convert.ToUInt32 (m_value);
586 }
587
588 ulong IConvertible.ToUInt64 (IFormatProvider provider)
589 {
590 return System.Convert.ToUInt64 (m_value);
591 }
592 }
593 }
git-svn mirror of mcs