mcs/class/corlib/System/DateTime.cs

   1 //\r
   2 // System.DateTime.cs\r
   3 //\r
   4 // author:\r
   5 //   Marcel Narings (marcel@narings.nl)\r
   6 //   Martin Baulig (martin@gnome.org)\r
   7 //\r
   8 //   (C) 2001 Marcel Narings\r
   9 \r
  10 using System;\r
  11 using System.Globalization;\r
  12 using System.Runtime.CompilerServices;\r
  13 \r
  14 \r
  15 namespace System\r
  16 {\r
  17         /// <summary>\r
  18         /// The DateTime structure represents dates and time ranging from\r
  19         /// 1-1-0001 12:00:00 AM to 31-12-9999 23:59:00 Common Era.\r
  20         /// </summary>\r
  21         /// \r
  22         [Serializable]\r
  23         public struct DateTime : IComparable , IFormattable  , IConvertible\r
  24         {\r
  25                 private TimeSpan ticks;\r
  26 \r
  27                 private const int dp400 = 146097;\r
  28                 private const int dp100 = 36524;\r
  29                 private const int dp4 = 1461;\r
  30 \r
  31                 // w32 file time starts counting from 1/1/1601 00:00 GMT\r
  32                 // which is the constant ticks from the .NET epoch\r
  33                 private const long w32file_epoch = 504911232000000000L;\r
  34 \r
  35                 //\r
  36                 // The UnixEpoch, it begins on Jan 1, 1970 at 0:0:0, expressed\r
  37                 // in Ticks\r
  38                 //\r
  39                 internal const long UnixEpoch = 621355968000000000L;\r
  40                 \r
  41                 public static readonly DateTime MaxValue = new DateTime (false,TimeSpan.MaxValue);\r
  42                 public static readonly DateTime MinValue = new DateTime (false,TimeSpan.MinValue);\r
  43                 \r
  44                 private enum Which \r
  45                 {\r
  46                         Day,\r
  47                         DayYear,\r
  48                         Month,\r
  49                         Year\r
  50                 };\r
  51         \r
  52                 private static int[] daysmonth = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; \r
  53                 private static int[] daysmonthleap = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };     \r
  54 \r
  55                 private static int AbsoluteDays (int year, int month, int day)\r
  56                 {\r
  57                         int[] days;\r
  58                         int temp = 0, m=1 ;\r
  59                 \r
  60                         days = (IsLeapYear(year) ? daysmonthleap  : daysmonth);\r
  61                         \r
  62                         while (m < month)\r
  63                                 temp += days[m++];\r
  64                         return ((day-1) + temp + (365* (year-1)) + ((year-1)/4) - ((year-1)/100) + ((year-1)/400));\r
  65                 }\r
  66 \r
  67                 private int FromTicks(Which what)\r
  68                 {\r
  69                         int num400, num100, num4, numyears; \r
  70                         int M =1;\r
  71 \r
  72                         int[] days = daysmonth;\r
  73                         int totaldays = this.ticks.Days;\r
  74 \r
  75                         num400 = (totaldays / dp400);\r
  76                         totaldays -=  num400 * dp400;\r
  77                 \r
  78                         num100 = (totaldays / dp100);\r
  79                         if (num100 == 4)   // leap\r
  80                                 num100 = 3;\r
  81                         totaldays -= (num100 * dp100);\r
  82 \r
  83                         num4 = totaldays / dp4;\r
  84                         totaldays -= (num4 * dp4);\r
  85 \r
  86                         numyears = totaldays / 365 ;\r
  87 \r
  88                         if (numyears == 4)  //leap\r
  89                                 numyears =3 ;\r
  90                         if (what == Which.Year )\r
  91                                 return num400*400 + num100*100 + num4*4 + numyears + 1;\r
  92 \r
  93                         totaldays -= (numyears * 365) ;\r
  94                         if (what == Which.DayYear )\r
  95                                 return totaldays + 1;\r
  96                         \r
  97                         if  ((numyears==3) && ((num100 == 3) || !(num4 == 24)) ) //31 dec leapyear\r
  98                                 days = daysmonthleap;\r
  99                                 \r
 100                         while (totaldays >= days[M])\r
 101                                 totaldays -= days[M++];\r
 102 \r
 103                         if (what == Which.Month )\r
 104                                 return M;\r
 105 \r
 106                         return totaldays +1; \r
 107                 }\r
 108 \r
 109 \r
 110                 // Constructors\r
 111                 \r
 112                 /// <summary>\r
 113                 /// Constructs a DateTime for specified ticks\r
 114                 /// </summary>\r
 115                 /// \r
 116                 public DateTime (long newticks)\r
 117                         // `local' must default to false here to avoid\r
 118                         // a recursion loop.\r
 119                         : this (false, newticks) {}\r
 120 \r
 121                 internal DateTime (bool local, long newticks)\r
 122                         : this (true, new TimeSpan (newticks))\r
 123                 {\r
 124                         if (local) {\r
 125                                 TimeZone tz = TimeZone.CurrentTimeZone;\r
 126 \r
 127                                 TimeSpan utcoffset = tz.GetUtcOffset (this);\r
 128 \r
 129                                 ticks = ticks + utcoffset;\r
 130                         }\r
 131                 }\r
 132 \r
 133                 public DateTime (int year, int month, int day)\r
 134                         : this (year, month, day,0,0,0,0) {}\r
 135 \r
 136                 public DateTime (int year, int month, int day, int hour, int minute, int second)\r
 137                         : this (year, month, day, hour, minute, second, 0)      {}\r
 138 \r
 139                 public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond)\r
 140                         {\r
 141                         if ( year < 1 || year > 9999 || \r
 142                                 month < 1 || month >12  ||\r
 143                                 day < 1 || day > DaysInMonth(year, month) ||\r
 144                                 hour < 0 || hour > 23 ||\r
 145                                 minute < 0 || minute > 59 ||\r
 146                                 second < 0 || second > 59 )\r
 147                                 throw new ArgumentOutOfRangeException() ;\r
 148 \r
 149                         ticks = new TimeSpan (AbsoluteDays(year,month,day), hour, minute, second, millisecond);\r
 150                 }\r
 151 \r
 152                 public DateTime (int year, int month, int day, Calendar calendar)\r
 153                         : this (year, month, day, 0, 0, 0, 0, calendar) {}\r
 154 \r
 155                 \r
 156                 public DateTime (int year, int month, int day, int hour, int minute, int second, Calendar calendar)\r
 157                         : this (year, month, day, hour, minute, second, 0, calendar)    {}\r
 158 \r
 159 \r
 160                 public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar)\r
 161                         : this (year, month, day, hour, minute, second, millisecond) \r
 162                 {\r
 163                         if (calendar == null)\r
 164                                 throw new ArgumentNullException();\r
 165                 }\r
 166 \r
 167                 internal DateTime (bool check, TimeSpan value)\r
 168                 {\r
 169                         if (check && (value.Ticks < MinValue.Ticks || value.Ticks > MaxValue.Ticks))\r
 170                                 throw new ArgumentOutOfRangeException ();\r
 171 \r
 172                         ticks = value;\r
 173                 }\r
 174 \r
 175                 /* Properties  */\r
 176                  \r
 177                 public DateTime Date \r
 178                 {\r
 179                         get     \r
 180                         { \r
 181                                 return new DateTime (Year, Month, Day);\r
 182                         }\r
 183                 }\r
 184         \r
 185                 public int Month \r
 186                 {\r
 187                         get     \r
 188                         { \r
 189                                 return FromTicks(Which.Month); \r
 190                         }\r
 191                 }\r
 192 \r
 193                \r
 194                 public int Day\r
 195                 {\r
 196                         get \r
 197                         { \r
 198                                 return FromTicks(Which.Day); \r
 199                         }\r
 200                 }\r
 201 \r
 202                 public DayOfWeek DayOfWeek \r
 203                 {\r
 204                         get \r
 205                         { \r
 206                                 return ( (DayOfWeek) ((ticks.Days+1) % 7) ); \r
 207                         }\r
 208                 }\r
 209 \r
 210                 public int DayOfYear \r
 211                 {\r
 212                         get \r
 213                         { \r
 214                                 return FromTicks(Which.DayYear); \r
 215                         }\r
 216                 }\r
 217 \r
 218                 public TimeSpan TimeOfDay \r
 219                 {\r
 220                         get     \r
 221                         { \r
 222                                 return new TimeSpan(ticks.Ticks % TimeSpan.TicksPerDay );\r
 223                         }\r
 224                         \r
 225                 }\r
 226 \r
 227                 public int Hour \r
 228                 {\r
 229                         get \r
 230                         { \r
 231                                 return ticks.Hours;\r
 232                         }\r
 233                 }\r
 234 \r
 235                 public int Minute \r
 236                 {\r
 237                         get \r
 238                         { \r
 239                                 return ticks.Minutes;\r
 240                         }\r
 241                 }\r
 242 \r
 243                 public int Second \r
 244                 {\r
 245                         get     \r
 246                         { \r
 247                                 return ticks.Seconds;\r
 248                         }\r
 249                 }\r
 250 \r
 251                 public int Millisecond \r
 252                 {\r
 253                         get \r
 254                         { \r
 255                                 return ticks.Milliseconds;\r
 256                         }\r
 257                 }\r
 258                 \r
 259                 [MethodImplAttribute(MethodImplOptions.InternalCall)]\r
 260                 internal static extern long GetNow ();\r
 261 \r
 262                 public static DateTime Now \r
 263                 {\r
 264                         get     \r
 265                         {\r
 266                                 return new DateTime (true, GetNow ());\r
 267                         }\r
 268                 }\r
 269 \r
 270                 public long Ticks\r
 271                 { \r
 272                         get     \r
 273                         { \r
 274                                 return ticks.Ticks;\r
 275                         }\r
 276                 }\r
 277         \r
 278                 public static DateTime Today \r
 279                 {\r
 280                         get     \r
 281                         {\r
 282                                 return new DateTime (false, (GetNow () / TimeSpan.TicksPerDay) * TimeSpan.TicksPerDay);\r
 283                         }\r
 284                 }\r
 285 \r
 286                 public static DateTime UtcNow \r
 287                 {\r
 288                         get {\r
 289                                 return new DateTime (GetNow ());\r
 290                         }\r
 291                 }\r
 292 \r
 293                 public int Year \r
 294                 {\r
 295                         get \r
 296                         { \r
 297                                 return FromTicks(Which.Year); \r
 298                         }\r
 299                 }\r
 300 \r
 301                 /* methods */\r
 302 \r
 303                 public DateTime Add (TimeSpan ts)\r
 304                 {\r
 305                         return new DateTime (true, ticks) + ts;\r
 306                 }\r
 307 \r
 308                 public DateTime AddDays (double days)\r
 309                 {\r
 310                         return AddMilliseconds (days * 86400000);\r
 311                 }\r
 312                 \r
 313                 public DateTime AddTicks (long t)\r
 314                 {\r
 315                         return Add (new TimeSpan (t));\r
 316                 }\r
 317 \r
 318                 public DateTime AddHours (double hours)\r
 319                 {\r
 320                         return AddMilliseconds (hours * 3600000);\r
 321                 }\r
 322 \r
 323                 public DateTime AddMilliseconds (double ms)\r
 324                 {\r
 325                         long msticks;\r
 326                         \r
 327                         msticks = (long) (ms += ms > 0 ? 0.5 : -0.5) * TimeSpan.TicksPerMillisecond ; \r
 328 \r
 329                         return AddTicks (msticks);\r
 330                 }\r
 331 \r
 332                 public DateTime AddMinutes (double minutes)\r
 333                 {\r
 334                         return AddMilliseconds (minutes * 60000);\r
 335                 }\r
 336                 \r
 337                 public DateTime AddMonths (int months)\r
 338                 {\r
 339                         int day, month, year,  maxday ;\r
 340                         DateTime temp ;\r
 341 \r
 342                         day = this.Day;\r
 343                         month = this.Month + (months % 12);\r
 344                         year = this.Year + months/12 ;\r
 345                         \r
 346                         if (month < 1)\r
 347                         {\r
 348                                 month = 12 + month ;\r
 349                                 year -- ;\r
 350                         }\r
 351                         else if (month>12) \r
 352                         {\r
 353                                 month = month -12;\r
 354                                 year ++;\r
 355                         }\r
 356                         maxday = DaysInMonth(year, month);\r
 357                         if (day > maxday)\r
 358                                 day = maxday;\r
 359 \r
 360                         temp = new DateTime (year, month, day);\r
 361                         return  temp.Add (this.TimeOfDay);\r
 362                 }\r
 363 \r
 364                 public DateTime AddSeconds (double seconds)\r
 365                 {\r
 366                         return AddMilliseconds (seconds*1000);\r
 367                 }\r
 368 \r
 369                 public DateTime AddYears (int years )\r
 370                 {\r
 371                         return AddMonths(years * 12);\r
 372                 }\r
 373 \r
 374                 public static int Compare (DateTime t1, DateTime t2)\r
 375                 {\r
 376                         if (t1.ticks < t2.ticks) \r
 377                                 return -1;\r
 378                         else if (t1.ticks > t2.ticks) \r
 379                                 return 1;\r
 380                         else\r
 381                                 return 0;\r
 382                 }\r
 383 \r
 384                 public int CompareTo (object v)\r
 385                 {\r
 386                         if ( v == null)\r
 387                                 return 1;\r
 388 \r
 389                         if (!(v is System.DateTime))\r
 390                                 throw new ArgumentException (Locale.GetText (\r
 391                                         "Value is not a System.DateTime"));\r
 392 \r
 393                         return Compare (this, (DateTime) v);\r
 394                 }\r
 395 \r
 396                 public static int DaysInMonth (int year, int month)\r
 397                 {\r
 398                         int[] days ;\r
 399 \r
 400                         if (month < 1 || month >12)\r
 401                                 throw new ArgumentOutOfRangeException ();\r
 402 \r
 403                         days = (IsLeapYear(year) ? daysmonthleap  : daysmonth);\r
 404                         return days[month];                     \r
 405                 }\r
 406                 \r
 407                 public override bool Equals (object o)\r
 408                 {\r
 409                         if (!(o is System.DateTime))\r
 410                                 return false;\r
 411 \r
 412                         return ((DateTime) o).ticks == ticks;\r
 413                 }\r
 414 \r
 415                 public static bool Equals (DateTime t1, DateTime t2 )\r
 416                 {\r
 417                         return (t1.ticks == t2.ticks );\r
 418                 }\r
 419 \r
 420                 public static DateTime FromFileTime (long fileTime) \r
 421                 {\r
 422                         return new DateTime (w32file_epoch + fileTime);\r
 423                 }\r
 424 \r
 425                 // TODO: Implement me.\r
 426                 [MonoTODO]\r
 427                 public static DateTime FromOADate (double d)\r
 428                 {\r
 429                                 return new DateTime(0);\r
 430                 }\r
 431                 \r
 432                 // TODO: Implement me.\r
 433                 [MonoTODO]\r
 434                 public string[] GetDateTimeFormats() \r
 435                 {\r
 436                         return null;\r
 437                 }\r
 438 \r
 439                 //TODO: implement me\r
 440                 [MonoTODO]\r
 441                 public string[] GetDateTimeFormats(char format)\r
 442                 {\r
 443                         return null;\r
 444                 }\r
 445                 \r
 446                 // TODO: implement me\r
 447                 [MonoTODO]\r
 448                 public string[] GetDateTimeFormats(IFormatProvider provider)\r
 449                 {\r
 450                         return null;\r
 451                 }\r
 452 \r
 453                 //TODO: implement me \r
 454                 [MonoTODO]\r
 455                 public string[] GetDateTimeFormats(char format,IFormatProvider provider )\r
 456                 {\r
 457                         return null;\r
 458                 }\r
 459 \r
 460                 public override int GetHashCode ()\r
 461                 {\r
 462                         return (int) ticks.Ticks;\r
 463                 }\r
 464 \r
 465                 public TypeCode GetTypeCode ()\r
 466                 {\r
 467                         return TypeCode.DateTime;\r
 468                 }\r
 469 \r
 470                 public static bool IsLeapYear (int year)\r
 471                 {\r
 472                         return  ( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ;\r
 473                 }\r
 474 \r
 475                 public static DateTime Parse (string s)\r
 476                 {\r
 477                         return Parse (s, null);\r
 478                 }\r
 479 \r
 480                 public static DateTime Parse (string s, IFormatProvider fp)\r
 481                 {\r
 482                         return Parse (s, null, DateTimeStyles.AllowWhiteSpaces);\r
 483                 }\r
 484 \r
 485                 public static DateTime Parse (string s, IFormatProvider fp, DateTimeStyles styles)\r
 486                 {\r
 487                         string[] formats = {\r
 488                                 // Full date and time\r
 489                                 "F", "G", "r", "s", "u", "U",\r
 490                                 // Full date and time, but no seconds\r
 491                                 "f", "g",\r
 492                                 // Only date\r
 493                                 "d", "D",\r
 494                                 // Only time\r
 495                                 "T", "t",\r
 496                                 // Only date, but no year\r
 497                                 "m",\r
 498                                 // Only date, but no day\r
 499                                 "y" \r
 500                         };\r
 501 \r
 502                         return ParseExact (s, formats, fp, styles);\r
 503                 }\r
 504 \r
 505                 public static DateTime ParseExact (string s, string format, IFormatProvider fp)\r
 506                 {\r
 507                         return ParseExact (s, format, fp, DateTimeStyles.None);\r
 508                 }\r
 509 \r
 510                 internal static int _ParseNumber (string s, int digits, bool leadingzero,\r
 511                                                   bool sloppy_parsing, out int num_parsed)\r
 512                 {\r
 513                         int number = 0, i;\r
 514 \r
 515                         if (sloppy_parsing)\r
 516                                 leadingzero = false;\r
 517 \r
 518                         if (!leadingzero) {\r
 519                                 int real_digits = 0;\r
 520                                 for (i = 0; i < digits; i++) {\r
 521                                         if ((i >= s.Length) || !Char.IsDigit (s[i]))\r
 522                                                 break;\r
 523 \r
 524                                         real_digits++;\r
 525                                 }\r
 526 \r
 527                                 digits = real_digits;\r
 528                         }\r
 529 \r
 530                         if (s.Length < digits) {\r
 531                                 num_parsed = -1;\r
 532                                 return 0;\r
 533                         }\r
 534 \r
 535                         for (i = 0; i < digits; i++) {\r
 536                                 char c = s[i];\r
 537                                 if (!Char.IsDigit (c)) {\r
 538                                         num_parsed = -1;\r
 539                                         return 0;\r
 540                                 }\r
 541 \r
 542                                 number = number * 10 + (byte) (c - '0');\r
 543                         }\r
 544 \r
 545                         num_parsed = digits;\r
 546                         return number;\r
 547                 }\r
 548 \r
 549                 internal static int _ParseEnum (string s, string[] values, out int num_parsed)\r
 550                 {\r
 551                         int i;\r
 552 \r
 553                         for (i = 0; i < values.Length; i++) {\r
 554                                 if (s.Length < values[i].Length)\r
 555                                         continue;\r
 556                                 String tmp = s.Substring (0, values[i].Length);\r
 557                                 if (String.Compare (tmp, values[i], true) == 0) {\r
 558                                         num_parsed = values[i].Length;\r
 559                                         return i;\r
 560                                 }\r
 561                         }\r
 562 \r
 563                         num_parsed = -1;\r
 564                         return -1;\r
 565                 }\r
 566 \r
 567                 internal static bool _ParseString (string s, int maxlength, string value, out int num_parsed)\r
 568                 {\r
 569                         if (maxlength > 0)\r
 570                                 value = value.Substring (0, maxlength);\r
 571 \r
 572                         s = s.Substring (0, value.Length);\r
 573 \r
 574                         if (String.Compare (s, value, true) == 0) {\r
 575                                 num_parsed = value.Length;\r
 576                                 return true;\r
 577                         }\r
 578 \r
 579                         num_parsed = -1;\r
 580                         return false;\r
 581                 }\r
 582 \r
 583                 internal static bool _DoParse (string s, string format, bool exact,\r
 584                                                out DateTime result,\r
 585                                                DateTimeFormatInfo dfi,\r
 586                                                DateTimeStyles style)\r
 587                 {\r
 588                         bool useutc = false, use_localtime = true;\r
 589                         bool sloppy_parsing = false;\r
 590 \r
 591                         if (format.Length == 1)\r
 592                                 format = _GetStandardPattern (format[0], dfi, out useutc);\r
 593 \r
 594                         if ((style & DateTimeStyles.AllowLeadingWhite) != 0) {\r
 595                                 format = format.TrimStart (null);\r
 596                                 s = s.TrimStart (null);\r
 597                         }\r
 598 \r
 599                         if ((style & DateTimeStyles.AllowTrailingWhite) != 0) {\r
 600                                 format = format.TrimEnd (null);\r
 601                                 s = s.TrimEnd (null);\r
 602                         }\r
 603 \r
 604                         if ((style & DateTimeStyles.AllowInnerWhite) != 0)\r
 605                                 sloppy_parsing = true;\r
 606 \r
 607                         char[] chars = format.ToCharArray ();\r
 608                         int len = format.Length, pos = 0, num = 0;\r
 609 \r
 610                         int day = -1, dayofweek = -1, month = -1, year = -1;\r
 611                         int hour = -1, minute = -1, second = -1, millisecond = -1;\r
 612                         int ampm = -1;\r
 613                         int tzsign = -1, tzoffset = -1, tzoffmin = -1;\r
 614 \r
 615                         result = new DateTime (0);\r
 616                         while (pos+num < len)\r
 617                         {\r
 618                                 if (s.Length == 0)\r
 619                                         return false;\r
 620 \r
 621                                 if (Char.IsWhiteSpace (s[0])) {\r
 622                                         s = s.Substring (1);\r
 623 \r
 624                                         if (Char.IsWhiteSpace (chars[pos])) {\r
 625                                                 pos++;\r
 626                                                 continue;\r
 627                                         }\r
 628 \r
 629                                         if ((style & DateTimeStyles.AllowInnerWhite) == 0)\r
 630                                                 return false;\r
 631                                 }\r
 632 \r
 633                                 if (chars[pos] == '\'') {\r
 634                                         num = 1;\r
 635                                         while (pos+num < len) {\r
 636                                                 if (chars[pos+num] == '\'')\r
 637                                                         break;\r
 638 \r
 639                                                 if (s.Length == 0)\r
 640                                                         return false;\r
 641                                                 if (s[0] != chars[pos+num])\r
 642                                                         return false;\r
 643                                                 s = s.Substring (1);\r
 644 \r
 645                                                 num++;\r
 646                                         }\r
 647                                         if (pos+num > len)\r
 648                                                 return false;\r
 649 \r
 650                                         pos += num + 1;\r
 651                                         num = 0;\r
 652                                         continue;\r
 653                                 } else if (chars[pos] == '\\') {\r
 654                                         if (pos+1 >= len)\r
 655                                                 return false;\r
 656 \r
 657                                         if (s[0] != chars[pos+num])\r
 658                                                 return false;\r
 659                                         s = s.Substring (1);\r
 660                                         if (s.Length == 0)\r
 661                                                 return false;\r
 662 \r
 663                                         pos++;\r
 664                                         continue;\r
 665                                 } else if (chars[pos] == '%') {\r
 666                                         pos++;\r
 667                                         continue;\r
 668                                 }\r
 669 \r
 670                                 if ((pos+num+1 < len) && (chars[pos+num+1] == chars[pos+num])) {\r
 671                                         num++;\r
 672                                         continue;\r
 673                                 }\r
 674 \r
 675                                 int num_parsed = 0;\r
 676 \r
 677                                 switch (chars[pos])\r
 678                                 {\r
 679                                 case 'd':\r
 680                                         if (day != -1)\r
 681                                                 return false;\r
 682                                         if (num == 0)\r
 683                                                 day = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 684                                         else if (num == 1)\r
 685                                                 day = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 686                                         else if (num == 2)\r
 687                                                 dayofweek = _ParseEnum (s, dfi.AbbreviatedDayNames, out num_parsed);\r
 688                                         else\r
 689                                         {\r
 690                                                 dayofweek = _ParseEnum (s, dfi.DayNames, out num_parsed);\r
 691                                                 num = 3;\r
 692                                         }\r
 693                                         break;\r
 694                                 case 'M':\r
 695                                         if (month != -1)\r
 696                                                 return false;\r
 697                                         if (num == 0)\r
 698                                                 month = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 699                                         else if (num == 1)\r
 700                                                 month = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 701                                         else if (num == 2)\r
 702                                                 month = _ParseEnum (s, dfi.AbbreviatedMonthNames , out num_parsed) + 1;\r
 703                                         else\r
 704                                         {\r
 705                                                 month = _ParseEnum (s, dfi.MonthNames, out num_parsed) + 1;\r
 706                                                 num = 3;\r
 707                                         }\r
 708                                         if ((month < 1) || (month > 12))\r
 709                                                 return false;\r
 710                                         break;\r
 711                                 case 'y':\r
 712                                         if (year != -1)\r
 713                                                 return false;\r
 714                                         if (num == 0) {\r
 715                                                 year = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 716                                                 year += (year < 30) ? 2000 : 1900;\r
 717                                         } else if (num < 3) {\r
 718                                                 year = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 719                                                 year += (year < 30) ? 2000 : 1900;\r
 720                                         } else {\r
 721                                                 year = _ParseNumber (s, 4, false, sloppy_parsing, out num_parsed);\r
 722                                                 num = 3;\r
 723                                         }\r
 724                                         break;\r
 725                                 case 'h':\r
 726                                         if (hour != -1)\r
 727                                                 return false;\r
 728                                         if (num == 0)\r
 729                                                 hour = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 730                                         else\r
 731                                         {\r
 732                                                 hour = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 733                                                 num = 1;\r
 734                                         }\r
 735                                         if (hour >= 12)\r
 736                                                 return false;\r
 737                                         break;\r
 738                                 case 'H':\r
 739                                         if ((hour != -1) || (ampm >= 0))\r
 740                                                 return false;\r
 741                                         if (num == 0)\r
 742                                                 hour = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 743                                         else\r
 744                                         {\r
 745                                                 hour = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 746                                                 num = 1;\r
 747                                         }\r
 748                                         if (hour >= 24)\r
 749                                                 return false;\r
 750                                         ampm = -2;\r
 751                                         break;\r
 752                                 case 'm':\r
 753                                         if (minute != -1)\r
 754                                                 return false;\r
 755                                         if (num == 0)\r
 756                                                 minute = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 757                                         else\r
 758                                         {\r
 759                                                 minute = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 760                                                 num = 1;\r
 761                                         }\r
 762                                         if (minute >= 60)\r
 763                                                 return false;\r
 764                                         break;\r
 765                                 case 's':\r
 766                                         if (second != -1)\r
 767                                                 return false;\r
 768                                         if (num == 0)\r
 769                                                 second = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 770                                         else\r
 771                                         {\r
 772                                                 second = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 773                                                 num = 1;\r
 774                                         }\r
 775                                         if (second >= 60)\r
 776                                                 return false;\r
 777                                         break;\r
 778                                 case 'f':\r
 779                                         if (millisecond != -1)\r
 780                                                 return false;\r
 781                                         num = Math.Min (num, 6);\r
 782                                         millisecond = _ParseNumber (s, num+1, true, sloppy_parsing, out num_parsed);\r
 783                                         break;\r
 784                                 case 't':\r
 785                                         if (ampm != -1)\r
 786                                                 return false;\r
 787                                         if (num == 0)\r
 788                                         {\r
 789                                                 if (_ParseString (s, 1, dfi.AMDesignator, out num_parsed))\r
 790                                                         ampm = 0;\r
 791                                                 else if (_ParseString (s, 1, dfi.PMDesignator, out num_parsed))\r
 792                                                         ampm = 1;\r
 793                                                 else\r
 794                                                         return false;\r
 795                                         }\r
 796                                         else\r
 797                                         {\r
 798                                                 if (_ParseString (s, 0, dfi.AMDesignator, out num_parsed))\r
 799                                                         ampm = 0;\r
 800                                                 else if (_ParseString (s, 0, dfi.PMDesignator, out num_parsed))\r
 801                                                         ampm = 1;\r
 802                                                 else\r
 803                                                         return false;\r
 804                                                 num = 1;\r
 805                                         }\r
 806                                         break;\r
 807                                 case 'z':\r
 808                                         if (tzsign != -1)\r
 809                                                 return false;\r
 810                                         if (s[0] == '+')\r
 811                                                 tzsign = 0;\r
 812                                         else if (s[0] == '-')\r
 813                                                 tzsign = 1;\r
 814                                         else\r
 815                                                 return false;\r
 816                                         s = s.Substring (1);\r
 817                                         if (num == 0)\r
 818                                                 tzoffset = _ParseNumber (s, 2, false, sloppy_parsing, out num_parsed);\r
 819                                         else if (num == 1)\r
 820                                                 tzoffset = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 821                                         else\r
 822                                         {\r
 823                                                 tzoffset = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 824                                                 if (num_parsed < 0)\r
 825                                                         return false;\r
 826                                                 s = s.Substring (num_parsed);\r
 827                                                 if (!_ParseString (s, 0, dfi.TimeSeparator, out num_parsed))\r
 828                                                         return false;\r
 829                                                 s = s.Substring (num_parsed);\r
 830                                                 tzoffmin = _ParseNumber (s, 2, true, sloppy_parsing, out num_parsed);\r
 831                                                 if (num_parsed < 0)\r
 832                                                         return false;\r
 833                                                 num = 2;\r
 834                                         }\r
 835                                         break;\r
 836                                 case ':':\r
 837                                         if (!_ParseString (s, 0, dfi.TimeSeparator, out num_parsed))\r
 838                                                 return false;\r
 839                                         break;\r
 840                                 case '/':\r
 841                                         if (!_ParseString (s, 0, dfi.DateSeparator, out num_parsed))\r
 842                                                 return false;\r
 843                                         break;\r
 844                                 default:\r
 845                                         if (s[0] != chars[pos])\r
 846                                                 return false;\r
 847                                         num = 0;\r
 848                                         num_parsed = 1;\r
 849                                         break;\r
 850                                 }\r
 851 \r
 852                                 if (num_parsed < 0)\r
 853                                         return false;\r
 854 \r
 855                                 s = s.Substring (num_parsed);\r
 856 \r
 857                                 pos = pos + num + 1;\r
 858                                 num = 0;\r
 859                         }\r
 860 \r
 861                         if (hour == -1)\r
 862                                 hour = 0;\r
 863                         if (minute == -1)\r
 864                                 minute = 0;\r
 865                         if (second == -1)\r
 866                                 second = 0;\r
 867                         if (millisecond == -1)\r
 868                                 millisecond = 0;\r
 869 \r
 870                         // If no date was given\r
 871                         if ((day == -1) && (month == -1) && (year == -1)) {\r
 872                                 if ((style & DateTimeStyles.NoCurrentDateDefault) != 0) {\r
 873                                         day = 1;\r
 874                                         month = 1;\r
 875                                         year = 1;\r
 876                                 } else {\r
 877                                         day = Today.Day;\r
 878                                         month = Today.Month;\r
 879                                         year = Today.Year;\r
 880                                 }\r
 881                         }\r
 882 \r
 883                         if (day == -1)\r
 884                                 day = 1;\r
 885                         if (month == -1)\r
 886                                 month = 1;\r
 887                         if (year == -1) {\r
 888                                 if ((style & DateTimeStyles.NoCurrentDateDefault) != 0)\r
 889                                         year = 1;\r
 890                                 else\r
 891                                         year = Today.Year;\r
 892                         }\r
 893 \r
 894                         if (ampm == 1)\r
 895                                 hour = hour + 12;\r
 896 \r
 897                         result = new DateTime (year, month, day, hour, minute, second, millisecond);\r
 898 \r
 899                         if ((dayofweek != -1) && (dayofweek != (int) result.DayOfWeek))\r
 900                                 throw new FormatException (Locale.GetText ("String was not recognized as valid DateTime because the day of week was incorrect."));\r
 901 \r
 902                         // If no timezone was specified, default to the local timezone.\r
 903                         TimeSpan utcoffset;\r
 904                         if (useutc)\r
 905                                 utcoffset = new TimeSpan (0, 0, 0);\r
 906                         else if (tzsign == -1) {\r
 907                                 TimeZone tz = TimeZone.CurrentTimeZone;\r
 908                                 utcoffset = tz.GetUtcOffset (result);\r
 909                         } else {\r
 910                                 if ((style & DateTimeStyles.AdjustToUniversal) != 0)\r
 911                                         use_localtime = false;\r
 912 \r
 913                                 if (tzoffmin == -1)\r
 914                                         tzoffmin = 0;\r
 915                                 if (tzoffset == -1)\r
 916                                         tzoffset = 0;\r
 917                                 if (tzsign == 1)\r
 918                                         tzoffset = -tzoffset;\r
 919 \r
 920                                 utcoffset = new TimeSpan (tzoffset, tzoffmin, 0);\r
 921                         }\r
 922 \r
 923                         long newticks = (result.ticks - utcoffset).Ticks;\r
 924 \r
 925                         result = new DateTime (use_localtime, newticks);\r
 926 \r
 927                         return true;\r
 928                 }\r
 929 \r
 930 \r
 931                 public static DateTime ParseExact (string s, string format,\r
 932                                                    IFormatProvider fp, DateTimeStyles style)\r
 933                 {\r
 934                         string[] formats;\r
 935 \r
 936                         formats = new string [1];\r
 937                         formats[0] = format;\r
 938 \r
 939                         return ParseExact (s, formats, fp, style);\r
 940                 }\r
 941 \r
 942                 public static DateTime ParseExact (string s, string[] formats,\r
 943                                                    IFormatProvider fp,\r
 944                                                    DateTimeStyles style)\r
 945                 {\r
 946                         DateTimeFormatInfo dfi = DateTimeFormatInfo.GetInstance (fp);\r
 947 \r
 948                         if (s == null)\r
 949                                 throw new ArgumentNullException (Locale.GetText ("s is null"));\r
 950                         if (formats.Length == 0)\r
 951                                 throw new ArgumentNullException (Locale.GetText ("format is null"));\r
 952 \r
 953                         int i;\r
 954                         for (i = 0; i < formats.Length; i++)\r
 955                         {\r
 956                                 DateTime result;\r
 957 \r
 958                                 if (_DoParse (s, formats[i], true, out result, dfi, style))\r
 959                                         return result;\r
 960                         }\r
 961 \r
 962                         throw new FormatException ();\r
 963                 }\r
 964                 \r
 965                 public TimeSpan Subtract(DateTime dt)\r
 966                 {   \r
 967                         return new TimeSpan(ticks.Ticks) - dt.ticks;\r
 968                 }\r
 969 \r
 970                 public DateTime Subtract(TimeSpan ts)\r
 971                 {\r
 972                         TimeSpan newticks;\r
 973 \r
 974                         newticks = (new TimeSpan (ticks.Ticks)) - ts;\r
 975                         return new DateTime(true,newticks);\r
 976                 }\r
 977 \r
 978                 public long ToFileTime()\r
 979                 {\r
 980                         if(ticks.Ticks < w32file_epoch) {\r
 981                                 throw new ArgumentOutOfRangeException("file time is not valid");\r
 982                         }\r
 983                         \r
 984                         return(ticks.Ticks - w32file_epoch);\r
 985                 }\r
 986 \r
 987                 public string ToLongDateString()\r
 988                 {\r
 989                         return ToString ("D");\r
 990                 }\r
 991 \r
 992                 public string ToLongTimeString()\r
 993                 {\r
 994                         return ToString ("T");\r
 995                 }\r
 996 \r
 997                 [MonoTODO]\r
 998                 public double ToOADate()\r
 999                 {\r
1000                         // TODO implement me \r
1001                         return 0;\r
1002                 }\r
1003 \r
1004                 public string ToShortDateString()\r
1005                 {\r
1006                         return ToString ("d");\r
1007                 }\r
1008 \r
1009                 public string ToShortTimeString()\r
1010                 {\r
1011                         return ToString ("t");\r
1012                 }\r
1013                 \r
1014                 public override string ToString ()\r
1015                 {\r
1016                         return ToString ("G", null);\r
1017                 }\r
1018 \r
1019                 public string ToString (IFormatProvider fp)\r
1020                 {\r
1021                         return ToString (null, fp);\r
1022                 }\r
1023 \r
1024                 public string ToString (string format)\r
1025                 {\r
1026                         return ToString (format, null);\r
1027                 }\r
1028 \r
1029                 internal static string _GetStandardPattern (char format, DateTimeFormatInfo dfi, out bool useutc)\r
1030                 {\r
1031                         String pattern;\r
1032 \r
1033                         useutc = false;\r
1034 \r
1035                         switch (format)\r
1036                         {\r
1037                         case 'd':\r
1038                                 pattern = dfi.ShortDatePattern;\r
1039                                 break;\r
1040                         case 'D':\r
1041                                 pattern = dfi.LongDatePattern;\r
1042                                 break;\r
1043                         case 'f':\r
1044                                 pattern = dfi.LongDatePattern + " " + dfi.ShortTimePattern;\r
1045                                 break;\r
1046                         case 'F':\r
1047                                 pattern = dfi.FullDateTimePattern;\r
1048                                 break;\r
1049                         case 'g':\r
1050                                 pattern = dfi.ShortDatePattern + " " + dfi.ShortTimePattern;\r
1051                                 break;\r
1052                         case 'G':\r
1053                                 pattern = dfi.ShortDatePattern + " " + dfi.LongTimePattern;\r
1054                                 break;\r
1055                         case 'm':\r
1056                         case 'M':\r
1057                                 pattern = dfi.MonthDayPattern;\r
1058                                 break;\r
1059                         case 'r':\r
1060                         case 'R':\r
1061                                 pattern = dfi.RFC1123Pattern;\r
1062                                 // commented by LP 09/jun/2002, rfc 1123 pattern is always in GMT\r
1063                                 // useutc= true;\r
1064                                 break;\r
1065                         case 's':\r
1066                                 pattern = dfi.SortableDateTimePattern;\r
1067                                 break;\r
1068                         case 't':\r
1069                                 pattern = dfi.ShortTimePattern;\r
1070                                 break;\r
1071                         case 'T':\r
1072                                 pattern = dfi.LongTimePattern;\r
1073                                 break;\r
1074                         case 'u':\r
1075                                 pattern = dfi.UniversalSortableDateTimePattern;\r
1076                                 useutc = true;\r
1077                                 break;\r
1078                         case 'U':\r
1079                                 pattern = dfi.LongDatePattern + " " + dfi.LongTimePattern;\r
1080                                 useutc = true;\r
1081                                 break;\r
1082                         case 'y':\r
1083                         case 'Y':\r
1084                                 pattern = dfi.YearMonthPattern;\r
1085                                 break;\r
1086                         default:\r
1087                                 pattern = null;\r
1088                                 break;\r
1089                         }\r
1090 \r
1091                         return pattern;\r
1092                 }\r
1093 \r
1094                 internal string _ToString (string format, DateTimeFormatInfo dfi)\r
1095                 {\r
1096                         String str = null, result = null;\r
1097                         char[] chars = format.ToCharArray ();\r
1098                         int len = format.Length, pos = 0, num = 0;\r
1099 \r
1100                         TimeZone tz = TimeZone.CurrentTimeZone;\r
1101                         TimeSpan utcoffset = tz.GetUtcOffset (this);\r
1102 \r
1103                         while (pos < len)\r
1104                         {\r
1105                                 if (chars[pos] == '\'') {\r
1106                                         num = 1;\r
1107                                         while (pos+num <= len) {\r
1108                                                 if (chars[pos+num] == '\'')\r
1109                                                         break;\r
1110 \r
1111                                                 result += chars[pos+num];\r
1112                                                 num++;\r
1113                                         }\r
1114                                         if (pos+num > len)\r
1115                                                 throw new FormatException (Locale.GetText ("The specified format is invalid"));\r
1116 \r
1117                                         pos += num+1;\r
1118                                         num = 0;\r
1119                                         continue;\r
1120                                 } else if (chars[pos] == '\\') {\r
1121                                         if (pos+1 >= len)\r
1122                                                 throw new FormatException (Locale.GetText ("The specified format is invalid"));\r
1123 \r
1124                                         result += chars[pos+1];\r
1125                                         pos += 2;\r
1126                                         continue;\r
1127                                 } else if (chars[pos] == '%') {\r
1128                                         pos++;\r
1129                                         continue;\r
1130                                 }\r
1131 \r
1132                                 if ((pos+num+1 < len) && (chars[pos+num+1] == chars[pos+num])) {\r
1133                                         num++;\r
1134                                         continue;\r
1135                                 }\r
1136 \r
1137                                 switch (chars[pos])\r
1138                                 {\r
1139                                 case 'd':\r
1140                                         if (num == 0)\r
1141                                                 str = Day.ToString ("d");\r
1142                                         else if (num == 1)\r
1143                                                 str = Day.ToString ("d02");\r
1144                                         else if (num == 2)\r
1145                                                 str = dfi.GetAbbreviatedDayName (DayOfWeek);\r
1146                                         else {\r
1147                                                 str = dfi.GetDayName (DayOfWeek);\r
1148                                                 num = 3;\r
1149                                         }\r
1150                                         break;\r
1151                                 case 'M':\r
1152                                         if (num == 0)\r
1153                                                 str = Month.ToString ("d");\r
1154                                         else if (num == 1)\r
1155                                                 str = Month.ToString ("d02");\r
1156                                         else if (num == 2)\r
1157                                                 str = dfi.GetAbbreviatedMonthName (Month);\r
1158                                         else {\r
1159                                                 str = dfi.GetMonthName (Month);\r
1160                                                 num = 3;\r
1161                                         }\r
1162                                         break;\r
1163                                 case 'y':\r
1164                                         if (num == 0) {\r
1165                                                 int shortyear = Year % 100;\r
1166                                                 str = shortyear.ToString ("d");\r
1167                                         } else if (num == 1) {\r
1168                                                 int shortyear = Year % 100;\r
1169                                                 str = shortyear.ToString ("d02");\r
1170                                         } else {\r
1171                                                 str = Year.ToString ("d");\r
1172                                                 num = 3;\r
1173                                         }\r
1174                                         break;\r
1175                                 case 'g':\r
1176                                         // FIXME\r
1177                                         break;\r
1178                                 case 'f':\r
1179                                         num = Math.Min (num, 6);\r
1180 \r
1181                                         long ms = (long) Millisecond;\r
1182                                         long exp = 10;\r
1183                                         for (int i = 0; i < num; i++)\r
1184                                                 exp = exp * 10;\r
1185                                         long maxexp = TimeSpan.TicksPerMillisecond;\r
1186 \r
1187                                         exp = Math.Min (exp, maxexp);\r
1188                                         ms = ms * exp / maxexp;\r
1189 \r
1190                                         String prec = (num+1).ToString ("d02");\r
1191                                         str = ms.ToString (String.Concat ("d", prec));\r
1192 \r
1193                                         break;\r
1194                                 case 'h':\r
1195                                         if (num == 0) {\r
1196                                                 int shorthour = Hour % 12;\r
1197                                                 str = shorthour.ToString ("d");\r
1198                                         } else {\r
1199                                                 int shorthour = Hour % 12;\r
1200                                                 str = shorthour.ToString ("d02");\r
1201                                                 num = 1;\r
1202                                         }\r
1203                                         break;\r
1204                                 case 'H':\r
1205                                         if (num == 0)\r
1206                                                 str = Hour.ToString ("d");\r
1207                                         else {\r
1208                                                 str = Hour.ToString ("d02");\r
1209                                                 num = 1;\r
1210                                         }\r
1211                                         break;\r
1212                                 case 'm':\r
1213                                         if (num == 0)\r
1214                                                 str = Minute.ToString ("d");\r
1215                                         else {\r
1216                                                 str = Minute.ToString ("d02");\r
1217                                                 num = 1;\r
1218                                         }\r
1219                                         break;\r
1220                                 case 's':\r
1221                                         if (num == 0)\r
1222                                                 str = Second.ToString ("d");\r
1223                                         else {\r
1224                                                 str = Second.ToString ("d02");\r
1225                                                 num = 1;\r
1226                                         }\r
1227                                         break;\r
1228                                 case 't':\r
1229                                         if (Hour < 12)\r
1230                                                 str = dfi.AMDesignator;\r
1231                                         else\r
1232                                                 str = dfi.PMDesignator;\r
1233 \r
1234                                         if (num == 0)\r
1235                                                 str = str.Substring (0,1);\r
1236                                         else\r
1237                                                 num = 1;\r
1238                                         break;\r
1239                                 case 'z':\r
1240                                         if (num == 0) {\r
1241                                                 int offset = utcoffset.Hours;\r
1242                                                 str = offset.ToString ("d");\r
1243                                                 if (offset > 0)\r
1244                                                         str = String.Concat ("+", str);\r
1245                                         } else if (num == 1) {\r
1246                                                 int offset = utcoffset.Hours;\r
1247                                                 str = offset.ToString ("d02");\r
1248                                                 if (offset > 0)\r
1249                                                         str = String.Concat ("+", str);\r
1250                                         } else if (num == 2) {\r
1251                                                 int offhour = utcoffset.Hours;\r
1252                                                 int offminute = utcoffset.Minutes;\r
1253                                                 str = offhour.ToString ("d02");\r
1254                                                 str = String.Concat (str, dfi.TimeSeparator);\r
1255                                                 str = String.Concat (str, offminute.ToString ("d02"));\r
1256                                                 if (offhour > 0)\r
1257                                                         str = String.Concat ("+", str);\r
1258                                                 num = 2;\r
1259                                         }\r
1260                                         break;\r
1261                                 case ':':\r
1262                                         str = dfi.TimeSeparator;\r
1263                                         num = 0;\r
1264                                         break;\r
1265                                 case '/':\r
1266                                         str = dfi.DateSeparator;\r
1267                                         num = 0;\r
1268                                         break;\r
1269                                 default:\r
1270                                         str = String.Concat (chars [pos]);\r
1271                                         num = 0;\r
1272                                         break;\r
1273                                 }\r
1274 \r
1275                                 result = String.Concat (result, str);\r
1276                                                 \r
1277                                 pos += num + 1;\r
1278                                 num = 0;\r
1279                         }\r
1280 \r
1281                         return result;\r
1282                 }\r
1283 \r
1284                 public string ToString (string format, IFormatProvider fp)\r
1285                 {\r
1286                         DateTimeFormatInfo dfi = DateTimeFormatInfo.GetInstance(fp);\r
1287 \r
1288                         if (format == null)\r
1289                                 format = dfi.FullDateTimePattern;\r
1290 \r
1291                         bool useutc = false;\r
1292 \r
1293                         if (format.Length == 1) {\r
1294                                 char fchar = (format.ToCharArray ())[0];\r
1295                                 format = _GetStandardPattern (fchar, dfi, out useutc);\r
1296                         }\r
1297 \r
1298                         if (useutc)\r
1299                                 return this.ToUniversalTime ()._ToString (format, dfi);\r
1300                         else\r
1301                                 return this._ToString (format, dfi);\r
1302                 }\r
1303 \r
1304                 public DateTime ToLocalTime()\r
1305                 {\r
1306                         TimeZone tz = TimeZone.CurrentTimeZone;\r
1307 \r
1308                         TimeSpan offset = tz.GetUtcOffset (this);\r
1309 \r
1310                         return new DateTime (true, ticks + offset);\r
1311                 }\r
1312 \r
1313                 public DateTime ToUniversalTime()\r
1314                 {\r
1315                         TimeZone tz = TimeZone.CurrentTimeZone;\r
1316 \r
1317                         TimeSpan offset = tz.GetUtcOffset (this);\r
1318 \r
1319                         return new DateTime (true, ticks - offset);\r
1320                 }\r
1321 \r
1322                 /*  OPERATORS */\r
1323 \r
1324                 public static DateTime operator +(DateTime d, TimeSpan t)\r
1325                 {\r
1326                         return new DateTime (true, d.ticks + t);\r
1327                 }\r
1328 \r
1329                 public static bool operator ==(DateTime d1, DateTime d2)\r
1330                 {\r
1331                         return (d1.ticks == d2.ticks);\r
1332                 }\r
1333 \r
1334                 public static bool operator >(DateTime t1,DateTime t2)\r
1335                 {\r
1336                         return (t1.ticks > t2.ticks);\r
1337                 }\r
1338 \r
1339                 public static bool operator >=(DateTime t1,DateTime t2)\r
1340                 {\r
1341                         return (t1.ticks >= t2.ticks);\r
1342                 }\r
1343 \r
1344                 public static bool operator !=(DateTime d1, DateTime d2)\r
1345                 {\r
1346                         return (d1.ticks != d2.ticks);\r
1347                 }\r
1348 \r
1349                 public static bool operator <(DateTime t1,      DateTime t2)\r
1350                 {\r
1351                         return (t1.ticks < t2.ticks );\r
1352                 }\r
1353 \r
1354                 public static bool operator <=(DateTime t1,DateTime t2)\r
1355                 {\r
1356                         return (t1.ticks <= t2.ticks);\r
1357                 }\r
1358 \r
1359                 public static TimeSpan operator -(DateTime d1,DateTime d2)\r
1360                 {\r
1361                         return new TimeSpan((d1.ticks - d2.ticks).Ticks);\r
1362                 }\r
1363 \r
1364                 public static DateTime operator -(DateTime d,TimeSpan t)\r
1365                 {\r
1366                         return new DateTime (true, d.ticks - t);\r
1367                 }\r
1368 \r
1369                 bool IConvertible.ToBoolean(IFormatProvider provider)\r
1370                 {\r
1371                         throw new InvalidCastException();\r
1372                 }\r
1373                 \r
1374                 byte IConvertible.ToByte(IFormatProvider provider)\r
1375                 {\r
1376                         throw new InvalidCastException();\r
1377                 }\r
1378 \r
1379                 char IConvertible.ToChar(IFormatProvider provider)\r
1380                 {\r
1381                         throw new InvalidCastException();\r
1382                 }\r
1383 \r
1384                 // TODO Implement me\r
1385                 [MonoTODO]\r
1386                 public System.DateTime ToDateTime(IFormatProvider provider)\r
1387                 {\r
1388                         return new System.DateTime(true,this.ticks);\r
1389                 } \r
1390                 \r
1391                 decimal IConvertible.ToDecimal(IFormatProvider provider)\r
1392                 {\r
1393                          throw new InvalidCastException();\r
1394                 }\r
1395 \r
1396                 double IConvertible.ToDouble(IFormatProvider provider)\r
1397                 {\r
1398                         throw new InvalidCastException();\r
1399                 }\r
1400 \r
1401                 Int16 IConvertible.ToInt16(IFormatProvider provider)\r
1402                 {\r
1403                         throw new InvalidCastException();\r
1404                 }\r
1405 \r
1406                 Int32 IConvertible.ToInt32(IFormatProvider provider)\r
1407                 {\r
1408                         throw new InvalidCastException();\r
1409                 }\r
1410 \r
1411                 Int64 IConvertible.ToInt64(IFormatProvider provider)\r
1412                 {\r
1413                         throw new InvalidCastException();\r
1414                 }\r
1415 \r
1416                 [CLSCompliant(false)]\r
1417                 SByte IConvertible.ToSByte(IFormatProvider provider)\r
1418                 {\r
1419                         throw new InvalidCastException();\r
1420                 }\r
1421 \r
1422                 Single IConvertible.ToSingle(IFormatProvider provider)\r
1423                 {\r
1424                         throw new InvalidCastException();\r
1425                 }\r
1426 \r
1427                 object IConvertible.ToType(Type conversionType,IFormatProvider provider)\r
1428                 {\r
1429                         throw new InvalidCastException();\r
1430                 }\r
1431 \r
1432                 UInt16 IConvertible.ToUInt16(IFormatProvider provider)\r
1433                 {\r
1434                         throw new InvalidCastException();\r
1435                 }\r
1436                 \r
1437                 [CLSCompliant(false)]\r
1438                 UInt32 IConvertible.ToUInt32(IFormatProvider provider)\r
1439                 {\r
1440                         throw new InvalidCastException();\r
1441                 }\r
1442 \r
1443                 [CLSCompliant(false)]\r
1444                 UInt64 IConvertible.ToUInt64(IFormatProvider provider)\r
1445                 {\r
1446                         throw new InvalidCastException();\r
1447                 }\r
1448         }\r
1449 }\r
1450 \r
1451 namespace System\r
1452 {\r
1453         public enum DayOfWeek\r
1454         {\r
1455                 Sunday,\r
1456                 Monday,\r
1457                 Tuesday,\r
1458                 Wednesday,\r
1459                 Thursday,\r
1460                 Friday,\r
1461                 Saturday\r
1462         }\r
1463 }\r