Python-2.7.3/Modules/datetimemodule.c

No issues found

   1 /*  C implementation for the date/time type documented at
   2  *  http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage
   3  */
   4 
   5 #define PY_SSIZE_T_CLEAN
   6 
   7 #include "Python.h"
   8 #include "modsupport.h"
   9 #include "structmember.h"
  10 
  11 #include <time.h>
  12 
  13 #include "timefuncs.h"
  14 
  15 /* Differentiate between building the core module and building extension
  16  * modules.
  17  */
  18 #ifndef Py_BUILD_CORE
  19 #define Py_BUILD_CORE
  20 #endif
  21 #include "datetime.h"
  22 #undef Py_BUILD_CORE
  23 
  24 /* We require that C int be at least 32 bits, and use int virtually
  25  * everywhere.  In just a few cases we use a temp long, where a Python
  26  * API returns a C long.  In such cases, we have to ensure that the
  27  * final result fits in a C int (this can be an issue on 64-bit boxes).
  28  */
  29 #if SIZEOF_INT < 4
  30 #       error "datetime.c requires that C int have at least 32 bits"
  31 #endif
  32 
  33 #define MINYEAR 1
  34 #define MAXYEAR 9999
  35 #define MAXORDINAL 3652059 /* date(9999,12,31).toordinal() */
  36 
  37 /* Nine decimal digits is easy to communicate, and leaves enough room
  38  * so that two delta days can be added w/o fear of overflowing a signed
  39  * 32-bit int, and with plenty of room left over to absorb any possible
  40  * carries from adding seconds.
  41  */
  42 #define MAX_DELTA_DAYS 999999999
  43 
  44 /* Rename the long macros in datetime.h to more reasonable short names. */
  45 #define GET_YEAR                PyDateTime_GET_YEAR
  46 #define GET_MONTH               PyDateTime_GET_MONTH
  47 #define GET_DAY                 PyDateTime_GET_DAY
  48 #define DATE_GET_HOUR           PyDateTime_DATE_GET_HOUR
  49 #define DATE_GET_MINUTE         PyDateTime_DATE_GET_MINUTE
  50 #define DATE_GET_SECOND         PyDateTime_DATE_GET_SECOND
  51 #define DATE_GET_MICROSECOND    PyDateTime_DATE_GET_MICROSECOND
  52 
  53 /* Date accessors for date and datetime. */
  54 #define SET_YEAR(o, v)          (((o)->data[0] = ((v) & 0xff00) >> 8), \
  55                  ((o)->data[1] = ((v) & 0x00ff)))
  56 #define SET_MONTH(o, v)         (PyDateTime_GET_MONTH(o) = (v))
  57 #define SET_DAY(o, v)           (PyDateTime_GET_DAY(o) = (v))
  58 
  59 /* Date/Time accessors for datetime. */
  60 #define DATE_SET_HOUR(o, v)     (PyDateTime_DATE_GET_HOUR(o) = (v))
  61 #define DATE_SET_MINUTE(o, v)   (PyDateTime_DATE_GET_MINUTE(o) = (v))
  62 #define DATE_SET_SECOND(o, v)   (PyDateTime_DATE_GET_SECOND(o) = (v))
  63 #define DATE_SET_MICROSECOND(o, v)      \
  64     (((o)->data[7] = ((v) & 0xff0000) >> 16), \
  65      ((o)->data[8] = ((v) & 0x00ff00) >> 8), \
  66      ((o)->data[9] = ((v) & 0x0000ff)))
  67 
  68 /* Time accessors for time. */
  69 #define TIME_GET_HOUR           PyDateTime_TIME_GET_HOUR
  70 #define TIME_GET_MINUTE         PyDateTime_TIME_GET_MINUTE
  71 #define TIME_GET_SECOND         PyDateTime_TIME_GET_SECOND
  72 #define TIME_GET_MICROSECOND    PyDateTime_TIME_GET_MICROSECOND
  73 #define TIME_SET_HOUR(o, v)     (PyDateTime_TIME_GET_HOUR(o) = (v))
  74 #define TIME_SET_MINUTE(o, v)   (PyDateTime_TIME_GET_MINUTE(o) = (v))
  75 #define TIME_SET_SECOND(o, v)   (PyDateTime_TIME_GET_SECOND(o) = (v))
  76 #define TIME_SET_MICROSECOND(o, v)      \
  77     (((o)->data[3] = ((v) & 0xff0000) >> 16), \
  78      ((o)->data[4] = ((v) & 0x00ff00) >> 8), \
  79      ((o)->data[5] = ((v) & 0x0000ff)))
  80 
  81 /* Delta accessors for timedelta. */
  82 #define GET_TD_DAYS(o)          (((PyDateTime_Delta *)(o))->days)
  83 #define GET_TD_SECONDS(o)       (((PyDateTime_Delta *)(o))->seconds)
  84 #define GET_TD_MICROSECONDS(o)  (((PyDateTime_Delta *)(o))->microseconds)
  85 
  86 #define SET_TD_DAYS(o, v)       ((o)->days = (v))
  87 #define SET_TD_SECONDS(o, v)    ((o)->seconds = (v))
  88 #define SET_TD_MICROSECONDS(o, v) ((o)->microseconds = (v))
  89 
  90 /* p is a pointer to a time or a datetime object; HASTZINFO(p) returns
  91  * p->hastzinfo.
  92  */
  93 #define HASTZINFO(p)            (((_PyDateTime_BaseTZInfo *)(p))->hastzinfo)
  94 
  95 /* M is a char or int claiming to be a valid month.  The macro is equivalent
  96  * to the two-sided Python test
  97  *      1 <= M <= 12
  98  */
  99 #define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12)
 100 
 101 /* Forward declarations. */
 102 static PyTypeObject PyDateTime_DateType;
 103 static PyTypeObject PyDateTime_DateTimeType;
 104 static PyTypeObject PyDateTime_DeltaType;
 105 static PyTypeObject PyDateTime_TimeType;
 106 static PyTypeObject PyDateTime_TZInfoType;
 107 
 108 /* ---------------------------------------------------------------------------
 109  * Math utilities.
 110  */
 111 
 112 /* k = i+j overflows iff k differs in sign from both inputs,
 113  * iff k^i has sign bit set and k^j has sign bit set,
 114  * iff (k^i)&(k^j) has sign bit set.
 115  */
 116 #define SIGNED_ADD_OVERFLOWED(RESULT, I, J) \
 117     ((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0)
 118 
 119 /* Compute Python divmod(x, y), returning the quotient and storing the
 120  * remainder into *r.  The quotient is the floor of x/y, and that's
 121  * the real point of this.  C will probably truncate instead (C99
 122  * requires truncation; C89 left it implementation-defined).
 123  * Simplification:  we *require* that y > 0 here.  That's appropriate
 124  * for all the uses made of it.  This simplifies the code and makes
 125  * the overflow case impossible (divmod(LONG_MIN, -1) is the only
 126  * overflow case).
 127  */
 128 static int
 129 divmod(int x, int y, int *r)
 130 {
 131     int quo;
 132 
 133     assert(y > 0);
 134     quo = x / y;
 135     *r = x - quo * y;
 136     if (*r < 0) {
 137         --quo;
 138         *r += y;
 139     }
 140     assert(0 <= *r && *r < y);
 141     return quo;
 142 }
 143 
 144 /* Round a double to the nearest long.  |x| must be small enough to fit
 145  * in a C long; this is not checked.
 146  */
 147 static long
 148 round_to_long(double x)
 149 {
 150     if (x >= 0.0)
 151         x = floor(x + 0.5);
 152     else
 153         x = ceil(x - 0.5);
 154     return (long)x;
 155 }
 156 
 157 /* ---------------------------------------------------------------------------
 158  * General calendrical helper functions
 159  */
 160 
 161 /* For each month ordinal in 1..12, the number of days in that month,
 162  * and the number of days before that month in the same year.  These
 163  * are correct for non-leap years only.
 164  */
 165 static int _days_in_month[] = {
 166     0, /* unused; this vector uses 1-based indexing */
 167     31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 168 };
 169 
 170 static int _days_before_month[] = {
 171     0, /* unused; this vector uses 1-based indexing */
 172     0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
 173 };
 174 
 175 /* year -> 1 if leap year, else 0. */
 176 static int
 177 is_leap(int year)
 178 {
 179     /* Cast year to unsigned.  The result is the same either way, but
 180      * C can generate faster code for unsigned mod than for signed
 181      * mod (especially for % 4 -- a good compiler should just grab
 182      * the last 2 bits when the LHS is unsigned).
 183      */
 184     const unsigned int ayear = (unsigned int)year;
 185     return ayear % 4 == 0 && (ayear % 100 != 0 || ayear % 400 == 0);
 186 }
 187 
 188 /* year, month -> number of days in that month in that year */
 189 static int
 190 days_in_month(int year, int month)
 191 {
 192     assert(month >= 1);
 193     assert(month <= 12);
 194     if (month == 2 && is_leap(year))
 195         return 29;
 196     else
 197         return _days_in_month[month];
 198 }
 199 
 200 /* year, month -> number of days in year preceeding first day of month */
 201 static int
 202 days_before_month(int year, int month)
 203 {
 204     int days;
 205 
 206     assert(month >= 1);
 207     assert(month <= 12);
 208     days = _days_before_month[month];
 209     if (month > 2 && is_leap(year))
 210         ++days;
 211     return days;
 212 }
 213 
 214 /* year -> number of days before January 1st of year.  Remember that we
 215  * start with year 1, so days_before_year(1) == 0.
 216  */
 217 static int
 218 days_before_year(int year)
 219 {
 220     int y = year - 1;
 221     /* This is incorrect if year <= 0; we really want the floor
 222      * here.  But so long as MINYEAR is 1, the smallest year this
 223      * can see is 0 (this can happen in some normalization endcases),
 224      * so we'll just special-case that.
 225      */
 226     assert (year >= 0);
 227     if (y >= 0)
 228         return y*365 + y/4 - y/100 + y/400;
 229     else {
 230         assert(y == -1);
 231         return -366;
 232     }
 233 }
 234 
 235 /* Number of days in 4, 100, and 400 year cycles.  That these have
 236  * the correct values is asserted in the module init function.
 237  */
 238 #define DI4Y    1461    /* days_before_year(5); days in 4 years */
 239 #define DI100Y  36524   /* days_before_year(101); days in 100 years */
 240 #define DI400Y  146097  /* days_before_year(401); days in 400 years  */
 241 
 242 /* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */
 243 static void
 244 ord_to_ymd(int ordinal, int *year, int *month, int *day)
 245 {
 246     int n, n1, n4, n100, n400, leapyear, preceding;
 247 
 248     /* ordinal is a 1-based index, starting at 1-Jan-1.  The pattern of
 249      * leap years repeats exactly every 400 years.  The basic strategy is
 250      * to find the closest 400-year boundary at or before ordinal, then
 251      * work with the offset from that boundary to ordinal.  Life is much
 252      * clearer if we subtract 1 from ordinal first -- then the values
 253      * of ordinal at 400-year boundaries are exactly those divisible
 254      * by DI400Y:
 255      *
 256      *    D  M   Y            n              n-1
 257      *    -- --- ----        ----------     ----------------
 258      *    31 Dec -400        -DI400Y       -DI400Y -1
 259      *     1 Jan -399         -DI400Y +1   -DI400Y      400-year boundary
 260      *    ...
 261      *    30 Dec  000        -1             -2
 262      *    31 Dec  000         0             -1
 263      *     1 Jan  001         1              0          400-year boundary
 264      *     2 Jan  001         2              1
 265      *     3 Jan  001         3              2
 266      *    ...
 267      *    31 Dec  400         DI400Y        DI400Y -1
 268      *     1 Jan  401         DI400Y +1     DI400Y      400-year boundary
 269      */
 270     assert(ordinal >= 1);
 271     --ordinal;
 272     n400 = ordinal / DI400Y;
 273     n = ordinal % DI400Y;
 274     *year = n400 * 400 + 1;
 275 
 276     /* Now n is the (non-negative) offset, in days, from January 1 of
 277      * year, to the desired date.  Now compute how many 100-year cycles
 278      * precede n.
 279      * Note that it's possible for n100 to equal 4!  In that case 4 full
 280      * 100-year cycles precede the desired day, which implies the
 281      * desired day is December 31 at the end of a 400-year cycle.
 282      */
 283     n100 = n / DI100Y;
 284     n = n % DI100Y;
 285 
 286     /* Now compute how many 4-year cycles precede it. */
 287     n4 = n / DI4Y;
 288     n = n % DI4Y;
 289 
 290     /* And now how many single years.  Again n1 can be 4, and again
 291      * meaning that the desired day is December 31 at the end of the
 292      * 4-year cycle.
 293      */
 294     n1 = n / 365;
 295     n = n % 365;
 296 
 297     *year += n100 * 100 + n4 * 4 + n1;
 298     if (n1 == 4 || n100 == 4) {
 299         assert(n == 0);
 300         *year -= 1;
 301         *month = 12;
 302         *day = 31;
 303         return;
 304     }
 305 
 306     /* Now the year is correct, and n is the offset from January 1.  We
 307      * find the month via an estimate that's either exact or one too
 308      * large.
 309      */
 310     leapyear = n1 == 3 && (n4 != 24 || n100 == 3);
 311     assert(leapyear == is_leap(*year));
 312     *month = (n + 50) >> 5;
 313     preceding = (_days_before_month[*month] + (*month > 2 && leapyear));
 314     if (preceding > n) {
 315         /* estimate is too large */
 316         *month -= 1;
 317         preceding -= days_in_month(*year, *month);
 318     }
 319     n -= preceding;
 320     assert(0 <= n);
 321     assert(n < days_in_month(*year, *month));
 322 
 323     *day = n + 1;
 324 }
 325 
 326 /* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */
 327 static int
 328 ymd_to_ord(int year, int month, int day)
 329 {
 330     return days_before_year(year) + days_before_month(year, month) + day;
 331 }
 332 
 333 /* Day of week, where Monday==0, ..., Sunday==6.  1/1/1 was a Monday. */
 334 static int
 335 weekday(int year, int month, int day)
 336 {
 337     return (ymd_to_ord(year, month, day) + 6) % 7;
 338 }
 339 
 340 /* Ordinal of the Monday starting week 1 of the ISO year.  Week 1 is the
 341  * first calendar week containing a Thursday.
 342  */
 343 static int
 344 iso_week1_monday(int year)
 345 {
 346     int first_day = ymd_to_ord(year, 1, 1);     /* ord of 1/1 */
 347     /* 0 if 1/1 is a Monday, 1 if a Tue, etc. */
 348     int first_weekday = (first_day + 6) % 7;
 349     /* ordinal of closest Monday at or before 1/1 */
 350     int week1_monday  = first_day - first_weekday;
 351 
 352     if (first_weekday > 3)      /* if 1/1 was Fri, Sat, Sun */
 353         week1_monday += 7;
 354     return week1_monday;
 355 }
 356 
 357 /* ---------------------------------------------------------------------------
 358  * Range checkers.
 359  */
 360 
 361 /* Check that -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS.  If so, return 0.
 362  * If not, raise OverflowError and return -1.
 363  */
 364 static int
 365 check_delta_day_range(int days)
 366 {
 367     if (-MAX_DELTA_DAYS <= days && days <= MAX_DELTA_DAYS)
 368         return 0;
 369     PyErr_Format(PyExc_OverflowError,
 370                  "days=%d; must have magnitude <= %d",
 371                  days, MAX_DELTA_DAYS);
 372     return -1;
 373 }
 374 
 375 /* Check that date arguments are in range.  Return 0 if they are.  If they
 376  * aren't, raise ValueError and return -1.
 377  */
 378 static int
 379 check_date_args(int year, int month, int day)
 380 {
 381 
 382     if (year < MINYEAR || year > MAXYEAR) {
 383         PyErr_SetString(PyExc_ValueError,
 384                         "year is out of range");
 385         return -1;
 386     }
 387     if (month < 1 || month > 12) {
 388         PyErr_SetString(PyExc_ValueError,
 389                         "month must be in 1..12");
 390         return -1;
 391     }
 392     if (day < 1 || day > days_in_month(year, month)) {
 393         PyErr_SetString(PyExc_ValueError,
 394                         "day is out of range for month");
 395         return -1;
 396     }
 397     return 0;
 398 }
 399 
 400 /* Check that time arguments are in range.  Return 0 if they are.  If they
 401  * aren't, raise ValueError and return -1.
 402  */
 403 static int
 404 check_time_args(int h, int m, int s, int us)
 405 {
 406     if (h < 0 || h > 23) {
 407         PyErr_SetString(PyExc_ValueError,
 408                         "hour must be in 0..23");
 409         return -1;
 410     }
 411     if (m < 0 || m > 59) {
 412         PyErr_SetString(PyExc_ValueError,
 413                         "minute must be in 0..59");
 414         return -1;
 415     }
 416     if (s < 0 || s > 59) {
 417         PyErr_SetString(PyExc_ValueError,
 418                         "second must be in 0..59");
 419         return -1;
 420     }
 421     if (us < 0 || us > 999999) {
 422         PyErr_SetString(PyExc_ValueError,
 423                         "microsecond must be in 0..999999");
 424         return -1;
 425     }
 426     return 0;
 427 }
 428 
 429 /* ---------------------------------------------------------------------------
 430  * Normalization utilities.
 431  */
 432 
 433 /* One step of a mixed-radix conversion.  A "hi" unit is equivalent to
 434  * factor "lo" units.  factor must be > 0.  If *lo is less than 0, or
 435  * at least factor, enough of *lo is converted into "hi" units so that
 436  * 0 <= *lo < factor.  The input values must be such that int overflow
 437  * is impossible.
 438  */
 439 static void
 440 normalize_pair(int *hi, int *lo, int factor)
 441 {
 442     assert(factor > 0);
 443     assert(lo != hi);
 444     if (*lo < 0 || *lo >= factor) {
 445         const int num_hi = divmod(*lo, factor, lo);
 446         const int new_hi = *hi + num_hi;
 447         assert(! SIGNED_ADD_OVERFLOWED(new_hi, *hi, num_hi));
 448         *hi = new_hi;
 449     }
 450     assert(0 <= *lo && *lo < factor);
 451 }
 452 
 453 /* Fiddle days (d), seconds (s), and microseconds (us) so that
 454  *      0 <= *s < 24*3600
 455  *      0 <= *us < 1000000
 456  * The input values must be such that the internals don't overflow.
 457  * The way this routine is used, we don't get close.
 458  */
 459 static void
 460 normalize_d_s_us(int *d, int *s, int *us)
 461 {
 462     if (*us < 0 || *us >= 1000000) {
 463         normalize_pair(s, us, 1000000);
 464         /* |s| can't be bigger than about
 465          * |original s| + |original us|/1000000 now.
 466          */
 467 
 468     }
 469     if (*s < 0 || *s >= 24*3600) {
 470         normalize_pair(d, s, 24*3600);
 471         /* |d| can't be bigger than about
 472          * |original d| +
 473          * (|original s| + |original us|/1000000) / (24*3600) now.
 474          */
 475     }
 476     assert(0 <= *s && *s < 24*3600);
 477     assert(0 <= *us && *us < 1000000);
 478 }
 479 
 480 /* Fiddle years (y), months (m), and days (d) so that
 481  *      1 <= *m <= 12
 482  *      1 <= *d <= days_in_month(*y, *m)
 483  * The input values must be such that the internals don't overflow.
 484  * The way this routine is used, we don't get close.
 485  */
 486 static int
 487 normalize_y_m_d(int *y, int *m, int *d)
 488 {
 489     int dim;            /* # of days in month */
 490 
 491     /* This gets muddy:  the proper range for day can't be determined
 492      * without knowing the correct month and year, but if day is, e.g.,
 493      * plus or minus a million, the current month and year values make
 494      * no sense (and may also be out of bounds themselves).
 495      * Saying 12 months == 1 year should be non-controversial.
 496      */
 497     if (*m < 1 || *m > 12) {
 498         --*m;
 499         normalize_pair(y, m, 12);
 500         ++*m;
 501         /* |y| can't be bigger than about
 502          * |original y| + |original m|/12 now.
 503          */
 504     }
 505     assert(1 <= *m && *m <= 12);
 506 
 507     /* Now only day can be out of bounds (year may also be out of bounds
 508      * for a datetime object, but we don't care about that here).
 509      * If day is out of bounds, what to do is arguable, but at least the
 510      * method here is principled and explainable.
 511      */
 512     dim = days_in_month(*y, *m);
 513     if (*d < 1 || *d > dim) {
 514         /* Move day-1 days from the first of the month.  First try to
 515          * get off cheap if we're only one day out of range
 516          * (adjustments for timezone alone can't be worse than that).
 517          */
 518         if (*d == 0) {
 519             --*m;
 520             if (*m > 0)
 521                 *d = days_in_month(*y, *m);
 522             else {
 523                 --*y;
 524                 *m = 12;
 525                 *d = 31;
 526             }
 527         }
 528         else if (*d == dim + 1) {
 529             /* move forward a day */
 530             ++*m;
 531             *d = 1;
 532             if (*m > 12) {
 533                 *m = 1;
 534                 ++*y;
 535             }
 536         }
 537         else {
 538             int ordinal = ymd_to_ord(*y, *m, 1) +
 539                                       *d - 1;
 540             if (ordinal < 1 || ordinal > MAXORDINAL) {
 541                 goto error;
 542             } else {
 543                 ord_to_ymd(ordinal, y, m, d);
 544                 return 0;
 545             }
 546         }
 547     }
 548     assert(*m > 0);
 549     assert(*d > 0);
 550     if (MINYEAR <= *y && *y <= MAXYEAR)
 551         return 0;
 552  error:
 553     PyErr_SetString(PyExc_OverflowError,
 554             "date value out of range");
 555     return -1;
 556 
 557 }
 558 
 559 /* Fiddle out-of-bounds months and days so that the result makes some kind
 560  * of sense.  The parameters are both inputs and outputs.  Returns < 0 on
 561  * failure, where failure means the adjusted year is out of bounds.
 562  */
 563 static int
 564 normalize_date(int *year, int *month, int *day)
 565 {
 566     return normalize_y_m_d(year, month, day);
 567 }
 568 
 569 /* Force all the datetime fields into range.  The parameters are both
 570  * inputs and outputs.  Returns < 0 on error.
 571  */
 572 static int
 573 normalize_datetime(int *year, int *month, int *day,
 574                    int *hour, int *minute, int *second,
 575                    int *microsecond)
 576 {
 577     normalize_pair(second, microsecond, 1000000);
 578     normalize_pair(minute, second, 60);
 579     normalize_pair(hour, minute, 60);
 580     normalize_pair(day, hour, 24);
 581     return normalize_date(year, month, day);
 582 }
 583 
 584 /* ---------------------------------------------------------------------------
 585  * Basic object allocation:  tp_alloc implementations.  These allocate
 586  * Python objects of the right size and type, and do the Python object-
 587  * initialization bit.  If there's not enough memory, they return NULL after
 588  * setting MemoryError.  All data members remain uninitialized trash.
 589  *
 590  * We abuse the tp_alloc "nitems" argument to communicate whether a tzinfo
 591  * member is needed.  This is ugly, imprecise, and possibly insecure.
 592  * tp_basicsize for the time and datetime types is set to the size of the
 593  * struct that has room for the tzinfo member, so subclasses in Python will
 594  * allocate enough space for a tzinfo member whether or not one is actually
 595  * needed.  That's the "ugly and imprecise" parts.  The "possibly insecure"
 596  * part is that PyType_GenericAlloc() (which subclasses in Python end up
 597  * using) just happens today to effectively ignore the nitems argument
 598  * when tp_itemsize is 0, which it is for these type objects.  If that
 599  * changes, perhaps the callers of tp_alloc slots in this file should
 600  * be changed to force a 0 nitems argument unless the type being allocated
 601  * is a base type implemented in this file (so that tp_alloc is time_alloc
 602  * or datetime_alloc below, which know about the nitems abuse).
 603  */
 604 
 605 static PyObject *
 606 time_alloc(PyTypeObject *type, Py_ssize_t aware)
 607 {
 608     PyObject *self;
 609 
 610     self = (PyObject *)
 611         PyObject_MALLOC(aware ?
 612                         sizeof(PyDateTime_Time) :
 613                 sizeof(_PyDateTime_BaseTime));
 614     if (self == NULL)
 615         return (PyObject *)PyErr_NoMemory();
 616     PyObject_INIT(self, type);
 617     return self;
 618 }
 619 
 620 static PyObject *
 621 datetime_alloc(PyTypeObject *type, Py_ssize_t aware)
 622 {
 623     PyObject *self;
 624 
 625     self = (PyObject *)
 626         PyObject_MALLOC(aware ?
 627                         sizeof(PyDateTime_DateTime) :
 628                 sizeof(_PyDateTime_BaseDateTime));
 629     if (self == NULL)
 630         return (PyObject *)PyErr_NoMemory();
 631     PyObject_INIT(self, type);
 632     return self;
 633 }
 634 
 635 /* ---------------------------------------------------------------------------
 636  * Helpers for setting object fields.  These work on pointers to the
 637  * appropriate base class.
 638  */
 639 
 640 /* For date and datetime. */
 641 static void
 642 set_date_fields(PyDateTime_Date *self, int y, int m, int d)
 643 {
 644     self->hashcode = -1;
 645     SET_YEAR(self, y);
 646     SET_MONTH(self, m);
 647     SET_DAY(self, d);
 648 }
 649 
 650 /* ---------------------------------------------------------------------------
 651  * Create various objects, mostly without range checking.
 652  */
 653 
 654 /* Create a date instance with no range checking. */
 655 static PyObject *
 656 new_date_ex(int year, int month, int day, PyTypeObject *type)
 657 {
 658     PyDateTime_Date *self;
 659 
 660     self = (PyDateTime_Date *) (type->tp_alloc(type, 0));
 661     if (self != NULL)
 662         set_date_fields(self, year, month, day);
 663     return (PyObject *) self;
 664 }
 665 
 666 #define new_date(year, month, day) \
 667     new_date_ex(year, month, day, &PyDateTime_DateType)
 668 
 669 /* Create a datetime instance with no range checking. */
 670 static PyObject *
 671 new_datetime_ex(int year, int month, int day, int hour, int minute,
 672              int second, int usecond, PyObject *tzinfo, PyTypeObject *type)
 673 {
 674     PyDateTime_DateTime *self;
 675     char aware = tzinfo != Py_None;
 676 
 677     self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware));
 678     if (self != NULL) {
 679         self->hastzinfo = aware;
 680         set_date_fields((PyDateTime_Date *)self, year, month, day);
 681         DATE_SET_HOUR(self, hour);
 682         DATE_SET_MINUTE(self, minute);
 683         DATE_SET_SECOND(self, second);
 684         DATE_SET_MICROSECOND(self, usecond);
 685         if (aware) {
 686             Py_INCREF(tzinfo);
 687             self->tzinfo = tzinfo;
 688         }
 689     }
 690     return (PyObject *)self;
 691 }
 692 
 693 #define new_datetime(y, m, d, hh, mm, ss, us, tzinfo)           \
 694     new_datetime_ex(y, m, d, hh, mm, ss, us, tzinfo,            \
 695                     &PyDateTime_DateTimeType)
 696 
 697 /* Create a time instance with no range checking. */
 698 static PyObject *
 699 new_time_ex(int hour, int minute, int second, int usecond,
 700             PyObject *tzinfo, PyTypeObject *type)
 701 {
 702     PyDateTime_Time *self;
 703     char aware = tzinfo != Py_None;
 704 
 705     self = (PyDateTime_Time *) (type->tp_alloc(type, aware));
 706     if (self != NULL) {
 707         self->hastzinfo = aware;
 708         self->hashcode = -1;
 709         TIME_SET_HOUR(self, hour);
 710         TIME_SET_MINUTE(self, minute);
 711         TIME_SET_SECOND(self, second);
 712         TIME_SET_MICROSECOND(self, usecond);
 713         if (aware) {
 714             Py_INCREF(tzinfo);
 715             self->tzinfo = tzinfo;
 716         }
 717     }
 718     return (PyObject *)self;
 719 }
 720 
 721 #define new_time(hh, mm, ss, us, tzinfo)                \
 722     new_time_ex(hh, mm, ss, us, tzinfo, &PyDateTime_TimeType)
 723 
 724 /* Create a timedelta instance.  Normalize the members iff normalize is
 725  * true.  Passing false is a speed optimization, if you know for sure
 726  * that seconds and microseconds are already in their proper ranges.  In any
 727  * case, raises OverflowError and returns NULL if the normalized days is out
 728  * of range).
 729  */
 730 static PyObject *
 731 new_delta_ex(int days, int seconds, int microseconds, int normalize,
 732              PyTypeObject *type)
 733 {
 734     PyDateTime_Delta *self;
 735 
 736     if (normalize)
 737         normalize_d_s_us(&days, &seconds, &microseconds);
 738     assert(0 <= seconds && seconds < 24*3600);
 739     assert(0 <= microseconds && microseconds < 1000000);
 740 
 741     if (check_delta_day_range(days) < 0)
 742         return NULL;
 743 
 744     self = (PyDateTime_Delta *) (type->tp_alloc(type, 0));
 745     if (self != NULL) {
 746         self->hashcode = -1;
 747         SET_TD_DAYS(self, days);
 748         SET_TD_SECONDS(self, seconds);
 749         SET_TD_MICROSECONDS(self, microseconds);
 750     }
 751     return (PyObject *) self;
 752 }
 753 
 754 #define new_delta(d, s, us, normalize)  \
 755     new_delta_ex(d, s, us, normalize, &PyDateTime_DeltaType)
 756 
 757 /* ---------------------------------------------------------------------------
 758  * tzinfo helpers.
 759  */
 760 
 761 /* Ensure that p is None or of a tzinfo subclass.  Return 0 if OK; if not
 762  * raise TypeError and return -1.
 763  */
 764 static int
 765 check_tzinfo_subclass(PyObject *p)
 766 {
 767     if (p == Py_None || PyTZInfo_Check(p))
 768         return 0;
 769     PyErr_Format(PyExc_TypeError,
 770                  "tzinfo argument must be None or of a tzinfo subclass, "
 771                  "not type '%s'",
 772                  Py_TYPE(p)->tp_name);
 773     return -1;
 774 }
 775 
 776 /* Return tzinfo.methname(tzinfoarg), without any checking of results.
 777  * If tzinfo is None, returns None.
 778  */
 779 static PyObject *
 780 call_tzinfo_method(PyObject *tzinfo, char *methname, PyObject *tzinfoarg)
 781 {
 782     PyObject *result;
 783 
 784     assert(tzinfo && methname && tzinfoarg);
 785     assert(check_tzinfo_subclass(tzinfo) >= 0);
 786     if (tzinfo == Py_None) {
 787         result = Py_None;
 788         Py_INCREF(result);
 789     }
 790     else
 791         result = PyObject_CallMethod(tzinfo, methname, "O", tzinfoarg);
 792     return result;
 793 }
 794 
 795 /* If self has a tzinfo member, return a BORROWED reference to it.  Else
 796  * return NULL, which is NOT AN ERROR.  There are no error returns here,
 797  * and the caller must not decref the result.
 798  */
 799 static PyObject *
 800 get_tzinfo_member(PyObject *self)
 801 {
 802     PyObject *tzinfo = NULL;
 803 
 804     if (PyDateTime_Check(self) && HASTZINFO(self))
 805         tzinfo = ((PyDateTime_DateTime *)self)->tzinfo;
 806     else if (PyTime_Check(self) && HASTZINFO(self))
 807         tzinfo = ((PyDateTime_Time *)self)->tzinfo;
 808 
 809     return tzinfo;
 810 }
 811 
 812 /* Call getattr(tzinfo, name)(tzinfoarg), and extract an int from the
 813  * result.  tzinfo must be an instance of the tzinfo class.  If the method
 814  * returns None, this returns 0 and sets *none to 1.  If the method doesn't
 815  * return None or timedelta, TypeError is raised and this returns -1.  If it
 816  * returnsa timedelta and the value is out of range or isn't a whole number
 817  * of minutes, ValueError is raised and this returns -1.
 818  * Else *none is set to 0 and the integer method result is returned.
 819  */
 820 static int
 821 call_utc_tzinfo_method(PyObject *tzinfo, char *name, PyObject *tzinfoarg,
 822                        int *none)
 823 {
 824     PyObject *u;
 825     int result = -1;
 826 
 827     assert(tzinfo != NULL);
 828     assert(PyTZInfo_Check(tzinfo));
 829     assert(tzinfoarg != NULL);
 830 
 831     *none = 0;
 832     u = call_tzinfo_method(tzinfo, name, tzinfoarg);
 833     if (u == NULL)
 834         return -1;
 835 
 836     else if (u == Py_None) {
 837         result = 0;
 838         *none = 1;
 839     }
 840     else if (PyDelta_Check(u)) {
 841         const int days = GET_TD_DAYS(u);
 842         if (days < -1 || days > 0)
 843             result = 24*60;             /* trigger ValueError below */
 844         else {
 845             /* next line can't overflow because we know days
 846              * is -1 or 0 now
 847              */
 848             int ss = days * 24 * 3600 + GET_TD_SECONDS(u);
 849             result = divmod(ss, 60, &ss);
 850             if (ss || GET_TD_MICROSECONDS(u)) {
 851                 PyErr_Format(PyExc_ValueError,
 852                              "tzinfo.%s() must return a "
 853                              "whole number of minutes",
 854                              name);
 855                 result = -1;
 856             }
 857         }
 858     }
 859     else {
 860         PyErr_Format(PyExc_TypeError,
 861                      "tzinfo.%s() must return None or "
 862                      "timedelta, not '%s'",
 863                      name, Py_TYPE(u)->tp_name);
 864     }
 865 
 866     Py_DECREF(u);
 867     if (result < -1439 || result > 1439) {
 868         PyErr_Format(PyExc_ValueError,
 869                      "tzinfo.%s() returned %d; must be in "
 870                      "-1439 .. 1439",
 871                      name, result);
 872         result = -1;
 873     }
 874     return result;
 875 }
 876 
 877 /* Call tzinfo.utcoffset(tzinfoarg), and extract an integer from the
 878  * result.  tzinfo must be an instance of the tzinfo class.  If utcoffset()
 879  * returns None, call_utcoffset returns 0 and sets *none to 1.  If uctoffset()
 880  * doesn't return None or timedelta, TypeError is raised and this returns -1.
 881  * If utcoffset() returns an invalid timedelta (out of range, or not a whole
 882  * # of minutes), ValueError is raised and this returns -1.  Else *none is
 883  * set to 0 and the offset is returned (as int # of minutes east of UTC).
 884  */
 885 static int
 886 call_utcoffset(PyObject *tzinfo, PyObject *tzinfoarg, int *none)
 887 {
 888     return call_utc_tzinfo_method(tzinfo, "utcoffset", tzinfoarg, none);
 889 }
 890 
 891 /* Call tzinfo.name(tzinfoarg), and return the offset as a timedelta or None.
 892  */
 893 static PyObject *
 894 offset_as_timedelta(PyObject *tzinfo, char *name, PyObject *tzinfoarg) {
 895     PyObject *result;
 896 
 897     assert(tzinfo && name && tzinfoarg);
 898     if (tzinfo == Py_None) {
 899         result = Py_None;
 900         Py_INCREF(result);
 901     }
 902     else {
 903         int none;
 904         int offset = call_utc_tzinfo_method(tzinfo, name, tzinfoarg,
 905                                             &none);
 906         if (offset < 0 && PyErr_Occurred())
 907             return NULL;
 908         if (none) {
 909             result = Py_None;
 910             Py_INCREF(result);
 911         }
 912         else
 913             result = new_delta(0, offset * 60, 0, 1);
 914     }
 915     return result;
 916 }
 917 
 918 /* Call tzinfo.dst(tzinfoarg), and extract an integer from the
 919  * result.  tzinfo must be an instance of the tzinfo class.  If dst()
 920  * returns None, call_dst returns 0 and sets *none to 1.  If dst()
 921  & doesn't return None or timedelta, TypeError is raised and this
 922  * returns -1.  If dst() returns an invalid timedelta for a UTC offset,
 923  * ValueError is raised and this returns -1.  Else *none is set to 0 and
 924  * the offset is returned (as an int # of minutes east of UTC).
 925  */
 926 static int
 927 call_dst(PyObject *tzinfo, PyObject *tzinfoarg, int *none)
 928 {
 929     return call_utc_tzinfo_method(tzinfo, "dst", tzinfoarg, none);
 930 }
 931 
 932 /* Call tzinfo.tzname(tzinfoarg), and return the result.  tzinfo must be
 933  * an instance of the tzinfo class or None.  If tzinfo isn't None, and
 934  * tzname() doesn't return None or a string, TypeError is raised and this
 935  * returns NULL.
 936  */
 937 static PyObject *
 938 call_tzname(PyObject *tzinfo, PyObject *tzinfoarg)
 939 {
 940     PyObject *result;
 941 
 942     assert(tzinfo != NULL);
 943     assert(check_tzinfo_subclass(tzinfo) >= 0);
 944     assert(tzinfoarg != NULL);
 945 
 946     if (tzinfo == Py_None) {
 947         result = Py_None;
 948         Py_INCREF(result);
 949     }
 950     else
 951         result = PyObject_CallMethod(tzinfo, "tzname", "O", tzinfoarg);
 952 
 953     if (result != NULL && result != Py_None && ! PyString_Check(result)) {
 954         PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must "
 955                      "return None or a string, not '%s'",
 956                      Py_TYPE(result)->tp_name);
 957         Py_DECREF(result);
 958         result = NULL;
 959     }
 960     return result;
 961 }
 962 
 963 typedef enum {
 964               /* an exception has been set; the caller should pass it on */
 965           OFFSET_ERROR,
 966 
 967           /* type isn't date, datetime, or time subclass */
 968           OFFSET_UNKNOWN,
 969 
 970           /* date,
 971            * datetime with !hastzinfo
 972            * datetime with None tzinfo,
 973            * datetime where utcoffset() returns None
 974            * time with !hastzinfo
 975            * time with None tzinfo,
 976            * time where utcoffset() returns None
 977            */
 978           OFFSET_NAIVE,
 979 
 980           /* time or datetime where utcoffset() doesn't return None */
 981           OFFSET_AWARE
 982 } naivety;
 983 
 984 /* Classify an object as to whether it's naive or offset-aware.  See
 985  * the "naivety" typedef for details.  If the type is aware, *offset is set
 986  * to minutes east of UTC (as returned by the tzinfo.utcoffset() method).
 987  * If the type is offset-naive (or unknown, or error), *offset is set to 0.
 988  * tzinfoarg is the argument to pass to the tzinfo.utcoffset() method.
 989  */
 990 static naivety
 991 classify_utcoffset(PyObject *op, PyObject *tzinfoarg, int *offset)
 992 {
 993     int none;
 994     PyObject *tzinfo;
 995 
 996     assert(tzinfoarg != NULL);
 997     *offset = 0;
 998     tzinfo = get_tzinfo_member(op);     /* NULL means no tzinfo, not error */
 999     if (tzinfo == Py_None)
1000         return OFFSET_NAIVE;
1001     if (tzinfo == NULL) {
1002         /* note that a datetime passes the PyDate_Check test */
1003         return (PyTime_Check(op) || PyDate_Check(op)) ?
1004                OFFSET_NAIVE : OFFSET_UNKNOWN;
1005     }
1006     *offset = call_utcoffset(tzinfo, tzinfoarg, &none);
1007     if (*offset == -1 && PyErr_Occurred())
1008         return OFFSET_ERROR;
1009     return none ? OFFSET_NAIVE : OFFSET_AWARE;
1010 }
1011 
1012 /* Classify two objects as to whether they're naive or offset-aware.
1013  * This isn't quite the same as calling classify_utcoffset() twice:  for
1014  * binary operations (comparison and subtraction), we generally want to
1015  * ignore the tzinfo members if they're identical.  This is by design,
1016  * so that results match "naive" expectations when mixing objects from a
1017  * single timezone.  So in that case, this sets both offsets to 0 and
1018  * both naiveties to OFFSET_NAIVE.
1019  * The function returns 0 if everything's OK, and -1 on error.
1020  */
1021 static int
1022 classify_two_utcoffsets(PyObject *o1, int *offset1, naivety *n1,
1023                         PyObject *tzinfoarg1,
1024                         PyObject *o2, int *offset2, naivety *n2,
1025                         PyObject *tzinfoarg2)
1026 {
1027     if (get_tzinfo_member(o1) == get_tzinfo_member(o2)) {
1028         *offset1 = *offset2 = 0;
1029         *n1 = *n2 = OFFSET_NAIVE;
1030     }
1031     else {
1032         *n1 = classify_utcoffset(o1, tzinfoarg1, offset1);
1033         if (*n1 == OFFSET_ERROR)
1034             return -1;
1035         *n2 = classify_utcoffset(o2, tzinfoarg2, offset2);
1036         if (*n2 == OFFSET_ERROR)
1037             return -1;
1038     }
1039     return 0;
1040 }
1041 
1042 /* repr is like "someclass(arg1, arg2)".  If tzinfo isn't None,
1043  * stuff
1044  *     ", tzinfo=" + repr(tzinfo)
1045  * before the closing ")".
1046  */
1047 static PyObject *
1048 append_keyword_tzinfo(PyObject *repr, PyObject *tzinfo)
1049 {
1050     PyObject *temp;
1051 
1052     assert(PyString_Check(repr));
1053     assert(tzinfo);
1054     if (tzinfo == Py_None)
1055         return repr;
1056     /* Get rid of the trailing ')'. */
1057     assert(PyString_AsString(repr)[PyString_Size(repr)-1] == ')');
1058     temp = PyString_FromStringAndSize(PyString_AsString(repr),
1059                                       PyString_Size(repr) - 1);
1060     Py_DECREF(repr);
1061     if (temp == NULL)
1062         return NULL;
1063     repr = temp;
1064 
1065     /* Append ", tzinfo=". */
1066     PyString_ConcatAndDel(&repr, PyString_FromString(", tzinfo="));
1067 
1068     /* Append repr(tzinfo). */
1069     PyString_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
1070 
1071     /* Add a closing paren. */
1072     PyString_ConcatAndDel(&repr, PyString_FromString(")"));
1073     return repr;
1074 }
1075 
1076 /* ---------------------------------------------------------------------------
1077  * String format helpers.
1078  */
1079 
1080 static PyObject *
1081 format_ctime(PyDateTime_Date *date, int hours, int minutes, int seconds)
1082 {
1083     static const char *DayNames[] = {
1084         "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
1085     };
1086     static const char *MonthNames[] = {
1087         "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1088         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1089     };
1090 
1091     char buffer[128];
1092     int wday = weekday(GET_YEAR(date), GET_MONTH(date), GET_DAY(date));
1093 
1094     PyOS_snprintf(buffer, sizeof(buffer), "%s %s %2d %02d:%02d:%02d %04d",
1095                   DayNames[wday], MonthNames[GET_MONTH(date) - 1],
1096                   GET_DAY(date), hours, minutes, seconds,
1097                   GET_YEAR(date));
1098     return PyString_FromString(buffer);
1099 }
1100 
1101 /* Add an hours & minutes UTC offset string to buf.  buf has no more than
1102  * buflen bytes remaining.  The UTC offset is gotten by calling
1103  * tzinfo.uctoffset(tzinfoarg).  If that returns None, \0 is stored into
1104  * *buf, and that's all.  Else the returned value is checked for sanity (an
1105  * integer in range), and if that's OK it's converted to an hours & minutes
1106  * string of the form
1107  *   sign HH sep MM
1108  * Returns 0 if everything is OK.  If the return value from utcoffset() is
1109  * bogus, an appropriate exception is set and -1 is returned.
1110  */
1111 static int
1112 format_utcoffset(char *buf, size_t buflen, const char *sep,
1113                 PyObject *tzinfo, PyObject *tzinfoarg)
1114 {
1115     int offset;
1116     int hours;
1117     int minutes;
1118     char sign;
1119     int none;
1120 
1121     assert(buflen >= 1);
1122 
1123     offset = call_utcoffset(tzinfo, tzinfoarg, &none);
1124     if (offset == -1 && PyErr_Occurred())
1125         return -1;
1126     if (none) {
1127         *buf = '\0';
1128         return 0;
1129     }
1130     sign = '+';
1131     if (offset < 0) {
1132         sign = '-';
1133         offset = - offset;
1134     }
1135     hours = divmod(offset, 60, &minutes);
1136     PyOS_snprintf(buf, buflen, "%c%02d%s%02d", sign, hours, sep, minutes);
1137     return 0;
1138 }
1139 
1140 static PyObject *
1141 make_freplacement(PyObject *object)
1142 {
1143     char freplacement[64];
1144     if (PyTime_Check(object))
1145         sprintf(freplacement, "%06d", TIME_GET_MICROSECOND(object));
1146     else if (PyDateTime_Check(object))
1147         sprintf(freplacement, "%06d", DATE_GET_MICROSECOND(object));
1148     else
1149         sprintf(freplacement, "%06d", 0);
1150 
1151     return PyString_FromStringAndSize(freplacement, strlen(freplacement));
1152 }
1153 
1154 /* I sure don't want to reproduce the strftime code from the time module,
1155  * so this imports the module and calls it.  All the hair is due to
1156  * giving special meanings to the %z, %Z and %f format codes via a
1157  * preprocessing step on the format string.
1158  * tzinfoarg is the argument to pass to the object's tzinfo method, if
1159  * needed.
1160  */
1161 static PyObject *
1162 wrap_strftime(PyObject *object, const char *format, size_t format_len,
1163                 PyObject *timetuple, PyObject *tzinfoarg)
1164 {
1165     PyObject *result = NULL;            /* guilty until proved innocent */
1166 
1167     PyObject *zreplacement = NULL;      /* py string, replacement for %z */
1168     PyObject *Zreplacement = NULL;      /* py string, replacement for %Z */
1169     PyObject *freplacement = NULL;      /* py string, replacement for %f */
1170 
1171     const char *pin;            /* pointer to next char in input format */
1172     char ch;                    /* next char in input format */
1173 
1174     PyObject *newfmt = NULL;            /* py string, the output format */
1175     char *pnew;         /* pointer to available byte in output format */
1176     size_t totalnew;            /* number bytes total in output format buffer,
1177                                exclusive of trailing \0 */
1178     size_t usednew;     /* number bytes used so far in output format buffer */
1179 
1180     const char *ptoappend;      /* ptr to string to append to output buffer */
1181     size_t ntoappend;           /* # of bytes to append to output buffer */
1182 
1183     assert(object && format && timetuple);
1184 
1185     /* Give up if the year is before 1900.
1186      * Python strftime() plays games with the year, and different
1187      * games depending on whether envar PYTHON2K is set.  This makes
1188      * years before 1900 a nightmare, even if the platform strftime
1189      * supports them (and not all do).
1190      * We could get a lot farther here by avoiding Python's strftime
1191      * wrapper and calling the C strftime() directly, but that isn't
1192      * an option in the Python implementation of this module.
1193      */
1194     {
1195         long year;
1196         PyObject *pyyear = PySequence_GetItem(timetuple, 0);
1197         if (pyyear == NULL) return NULL;
1198         assert(PyInt_Check(pyyear));
1199         year = PyInt_AsLong(pyyear);
1200         Py_DECREF(pyyear);
1201         if (year < 1900) {
1202             PyErr_Format(PyExc_ValueError, "year=%ld is before "
1203                          "1900; the datetime strftime() "
1204                          "methods require year >= 1900",
1205                          year);
1206             return NULL;
1207         }
1208     }
1209 
1210     /* Scan the input format, looking for %z/%Z/%f escapes, building
1211      * a new format.  Since computing the replacements for those codes
1212      * is expensive, don't unless they're actually used.
1213      */
1214     if (format_len > INT_MAX - 1) {
1215         PyErr_NoMemory();
1216         goto Done;
1217     }
1218 
1219     totalnew = format_len + 1;          /* realistic if no %z/%Z/%f */
1220     newfmt = PyString_FromStringAndSize(NULL, totalnew);
1221     if (newfmt == NULL) goto Done;
1222     pnew = PyString_AsString(newfmt);
1223     usednew = 0;
1224 
1225     pin = format;
1226     while ((ch = *pin++) != '\0') {
1227         if (ch != '%') {
1228             ptoappend = pin - 1;
1229             ntoappend = 1;
1230         }
1231         else if ((ch = *pin++) == '\0') {
1232             /* There's a lone trailing %; doesn't make sense. */
1233             PyErr_SetString(PyExc_ValueError, "strftime format "
1234                             "ends with raw %");
1235             goto Done;
1236         }
1237         /* A % has been seen and ch is the character after it. */
1238         else if (ch == 'z') {
1239             if (zreplacement == NULL) {
1240                 /* format utcoffset */
1241                 char buf[100];
1242                 PyObject *tzinfo = get_tzinfo_member(object);
1243                 zreplacement = PyString_FromString("");
1244                 if (zreplacement == NULL) goto Done;
1245                 if (tzinfo != Py_None && tzinfo != NULL) {
1246                     assert(tzinfoarg != NULL);
1247                     if (format_utcoffset(buf,
1248                                          sizeof(buf),
1249                                          "",
1250                                          tzinfo,
1251                                          tzinfoarg) < 0)
1252                         goto Done;
1253                     Py_DECREF(zreplacement);
1254                     zreplacement = PyString_FromString(buf);
1255                     if (zreplacement == NULL) goto Done;
1256                 }
1257             }
1258             assert(zreplacement != NULL);
1259             ptoappend = PyString_AS_STRING(zreplacement);
1260             ntoappend = PyString_GET_SIZE(zreplacement);
1261         }
1262         else if (ch == 'Z') {
1263             /* format tzname */
1264             if (Zreplacement == NULL) {
1265                 PyObject *tzinfo = get_tzinfo_member(object);
1266                 Zreplacement = PyString_FromString("");
1267                 if (Zreplacement == NULL) goto Done;
1268                 if (tzinfo != Py_None && tzinfo != NULL) {
1269                     PyObject *temp;
1270                     assert(tzinfoarg != NULL);
1271                     temp = call_tzname(tzinfo, tzinfoarg);
1272                     if (temp == NULL) goto Done;
1273                     if (temp != Py_None) {
1274                         assert(PyString_Check(temp));
1275                         /* Since the tzname is getting
1276                          * stuffed into the format, we
1277                          * have to double any % signs
1278                          * so that strftime doesn't
1279                          * treat them as format codes.
1280                          */
1281                         Py_DECREF(Zreplacement);
1282                         Zreplacement = PyObject_CallMethod(
1283                             temp, "replace",
1284                             "ss", "%", "%%");
1285                         Py_DECREF(temp);
1286                         if (Zreplacement == NULL)
1287                             goto Done;
1288                         if (!PyString_Check(Zreplacement)) {
1289                             PyErr_SetString(PyExc_TypeError, "tzname.replace() did not return a string");
1290                             goto Done;
1291                         }
1292                     }
1293                     else
1294                         Py_DECREF(temp);
1295                 }
1296             }
1297             assert(Zreplacement != NULL);
1298             ptoappend = PyString_AS_STRING(Zreplacement);
1299             ntoappend = PyString_GET_SIZE(Zreplacement);
1300         }
1301         else if (ch == 'f') {
1302             /* format microseconds */
1303             if (freplacement == NULL) {
1304                 freplacement = make_freplacement(object);
1305                 if (freplacement == NULL)
1306                     goto Done;
1307             }
1308             assert(freplacement != NULL);
1309             assert(PyString_Check(freplacement));
1310             ptoappend = PyString_AS_STRING(freplacement);
1311             ntoappend = PyString_GET_SIZE(freplacement);
1312         }
1313         else {
1314             /* percent followed by neither z nor Z */
1315             ptoappend = pin - 2;
1316             ntoappend = 2;
1317         }
1318 
1319         /* Append the ntoappend chars starting at ptoappend to
1320          * the new format.
1321          */
1322         assert(ptoappend != NULL);
1323         assert(ntoappend >= 0);
1324         if (ntoappend == 0)
1325             continue;
1326         while (usednew + ntoappend > totalnew) {
1327             size_t bigger = totalnew << 1;
1328             if ((bigger >> 1) != totalnew) { /* overflow */
1329                 PyErr_NoMemory();
1330                 goto Done;
1331             }
1332             if (_PyString_Resize(&newfmt, bigger) < 0)
1333                 goto Done;
1334             totalnew = bigger;
1335             pnew = PyString_AsString(newfmt) + usednew;
1336         }
1337         memcpy(pnew, ptoappend, ntoappend);
1338         pnew += ntoappend;
1339         usednew += ntoappend;
1340         assert(usednew <= totalnew);
1341     }  /* end while() */
1342 
1343     if (_PyString_Resize(&newfmt, usednew) < 0)
1344         goto Done;
1345     {
1346         PyObject *time = PyImport_ImportModuleNoBlock("time");
1347         if (time == NULL)
1348             goto Done;
1349         result = PyObject_CallMethod(time, "strftime", "OO",
1350                                      newfmt, timetuple);
1351         Py_DECREF(time);
1352     }
1353  Done:
1354     Py_XDECREF(freplacement);
1355     Py_XDECREF(zreplacement);
1356     Py_XDECREF(Zreplacement);
1357     Py_XDECREF(newfmt);
1358     return result;
1359 }
1360 
1361 static char *
1362 isoformat_date(PyDateTime_Date *dt, char buffer[], int bufflen)
1363 {
1364     int x;
1365     x = PyOS_snprintf(buffer, bufflen,
1366                       "%04d-%02d-%02d",
1367                       GET_YEAR(dt), GET_MONTH(dt), GET_DAY(dt));
1368     assert(bufflen >= x);
1369     return buffer + x;
1370 }
1371 
1372 static char *
1373 isoformat_time(PyDateTime_DateTime *dt, char buffer[], int bufflen)
1374 {
1375     int x;
1376     int us = DATE_GET_MICROSECOND(dt);
1377 
1378     x = PyOS_snprintf(buffer, bufflen,
1379                       "%02d:%02d:%02d",
1380                       DATE_GET_HOUR(dt),
1381                       DATE_GET_MINUTE(dt),
1382                       DATE_GET_SECOND(dt));
1383     assert(bufflen >= x);
1384     if (us)
1385         x += PyOS_snprintf(buffer + x, bufflen - x, ".%06d", us);
1386     assert(bufflen >= x);
1387     return buffer + x;
1388 }
1389 
1390 /* ---------------------------------------------------------------------------
1391  * Wrap functions from the time module.  These aren't directly available
1392  * from C.  Perhaps they should be.
1393  */
1394 
1395 /* Call time.time() and return its result (a Python float). */
1396 static PyObject *
1397 time_time(void)
1398 {
1399     PyObject *result = NULL;
1400     PyObject *time = PyImport_ImportModuleNoBlock("time");
1401 
1402     if (time != NULL) {
1403         result = PyObject_CallMethod(time, "time", "()");
1404         Py_DECREF(time);
1405     }
1406     return result;
1407 }
1408 
1409 /* Build a time.struct_time.  The weekday and day number are automatically
1410  * computed from the y,m,d args.
1411  */
1412 static PyObject *
1413 build_struct_time(int y, int m, int d, int hh, int mm, int ss, int dstflag)
1414 {
1415     PyObject *time;
1416     PyObject *result = NULL;
1417 
1418     time = PyImport_ImportModuleNoBlock("time");
1419     if (time != NULL) {
1420         result = PyObject_CallMethod(time, "struct_time",
1421                                      "((iiiiiiiii))",
1422                                      y, m, d,
1423                                      hh, mm, ss,
1424                                      weekday(y, m, d),
1425                                      days_before_month(y, m) + d,
1426                                      dstflag);
1427         Py_DECREF(time);
1428     }
1429     return result;
1430 }
1431 
1432 /* ---------------------------------------------------------------------------
1433  * Miscellaneous helpers.
1434  */
1435 
1436 /* For obscure reasons, we need to use tp_richcompare instead of tp_compare.
1437  * The comparisons here all most naturally compute a cmp()-like result.
1438  * This little helper turns that into a bool result for rich comparisons.
1439  */
1440 static PyObject *
1441 diff_to_bool(int diff, int op)
1442 {
1443     PyObject *result;
1444     int istrue;
1445 
1446     switch (op) {
1447         case Py_EQ: istrue = diff == 0; break;
1448         case Py_NE: istrue = diff != 0; break;
1449         case Py_LE: istrue = diff <= 0; break;
1450         case Py_GE: istrue = diff >= 0; break;
1451         case Py_LT: istrue = diff < 0; break;
1452         case Py_GT: istrue = diff > 0; break;
1453         default:
1454             assert(! "op unknown");
1455             istrue = 0; /* To shut up compiler */
1456     }
1457     result = istrue ? Py_True : Py_False;
1458     Py_INCREF(result);
1459     return result;
1460 }
1461 
1462 /* Raises a "can't compare" TypeError and returns NULL. */
1463 static PyObject *
1464 cmperror(PyObject *a, PyObject *b)
1465 {
1466     PyErr_Format(PyExc_TypeError,
1467                  "can't compare %s to %s",
1468                  Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
1469     return NULL;
1470 }
1471 
1472 /* ---------------------------------------------------------------------------
1473  * Cached Python objects; these are set by the module init function.
1474  */
1475 
1476 /* Conversion factors. */
1477 static PyObject *us_per_us = NULL;      /* 1 */
1478 static PyObject *us_per_ms = NULL;      /* 1000 */
1479 static PyObject *us_per_second = NULL;  /* 1000000 */
1480 static PyObject *us_per_minute = NULL;  /* 1e6 * 60 as Python int */
1481 static PyObject *us_per_hour = NULL;    /* 1e6 * 3600 as Python long */
1482 static PyObject *us_per_day = NULL;     /* 1e6 * 3600 * 24 as Python long */
1483 static PyObject *us_per_week = NULL;    /* 1e6*3600*24*7 as Python long */
1484 static PyObject *seconds_per_day = NULL; /* 3600*24 as Python int */
1485 
1486 /* ---------------------------------------------------------------------------
1487  * Class implementations.
1488  */
1489 
1490 /*
1491  * PyDateTime_Delta implementation.
1492  */
1493 
1494 /* Convert a timedelta to a number of us,
1495  *      (24*3600*self.days + self.seconds)*1000000 + self.microseconds
1496  * as a Python int or long.
1497  * Doing mixed-radix arithmetic by hand instead is excruciating in C,
1498  * due to ubiquitous overflow possibilities.
1499  */
1500 static PyObject *
1501 delta_to_microseconds(PyDateTime_Delta *self)
1502 {
1503     PyObject *x1 = NULL;
1504     PyObject *x2 = NULL;
1505     PyObject *x3 = NULL;
1506     PyObject *result = NULL;
1507 
1508     x1 = PyInt_FromLong(GET_TD_DAYS(self));
1509     if (x1 == NULL)
1510         goto Done;
1511     x2 = PyNumber_Multiply(x1, seconds_per_day);        /* days in seconds */
1512     if (x2 == NULL)
1513         goto Done;
1514     Py_DECREF(x1);
1515     x1 = NULL;
1516 
1517     /* x2 has days in seconds */
1518     x1 = PyInt_FromLong(GET_TD_SECONDS(self));          /* seconds */
1519     if (x1 == NULL)
1520         goto Done;
1521     x3 = PyNumber_Add(x1, x2);          /* days and seconds in seconds */
1522     if (x3 == NULL)
1523         goto Done;
1524     Py_DECREF(x1);
1525     Py_DECREF(x2);
1526     x2 = NULL;
1527 
1528     /* x3 has days+seconds in seconds */
1529     x1 = PyNumber_Multiply(x3, us_per_second);          /* us */
1530     if (x1 == NULL)
1531         goto Done;
1532     Py_DECREF(x3);
1533     x3 = NULL;
1534 
1535     /* x1 has days+seconds in us */
1536     x2 = PyInt_FromLong(GET_TD_MICROSECONDS(self));
1537     if (x2 == NULL)
1538         goto Done;
1539     result = PyNumber_Add(x1, x2);
1540 
1541 Done:
1542     Py_XDECREF(x1);
1543     Py_XDECREF(x2);
1544     Py_XDECREF(x3);
1545     return result;
1546 }
1547 
1548 /* Convert a number of us (as a Python int or long) to a timedelta.
1549  */
1550 static PyObject *
1551 microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type)
1552 {
1553     int us;
1554     int s;
1555     int d;
1556     long temp;
1557 
1558     PyObject *tuple = NULL;
1559     PyObject *num = NULL;
1560     PyObject *result = NULL;
1561 
1562     tuple = PyNumber_Divmod(pyus, us_per_second);
1563     if (tuple == NULL)
1564         goto Done;
1565 
1566     num = PyTuple_GetItem(tuple, 1);            /* us */
1567     if (num == NULL)
1568         goto Done;
1569     temp = PyLong_AsLong(num);
1570     num = NULL;
1571     if (temp == -1 && PyErr_Occurred())
1572         goto Done;
1573     assert(0 <= temp && temp < 1000000);
1574     us = (int)temp;
1575     if (us < 0) {
1576         /* The divisor was positive, so this must be an error. */
1577         assert(PyErr_Occurred());
1578         goto Done;
1579     }
1580 
1581     num = PyTuple_GetItem(tuple, 0);            /* leftover seconds */
1582     if (num == NULL)
1583         goto Done;
1584     Py_INCREF(num);
1585     Py_DECREF(tuple);
1586 
1587     tuple = PyNumber_Divmod(num, seconds_per_day);
1588     if (tuple == NULL)
1589         goto Done;
1590     Py_DECREF(num);
1591 
1592     num = PyTuple_GetItem(tuple, 1);            /* seconds */
1593     if (num == NULL)
1594         goto Done;
1595     temp = PyLong_AsLong(num);
1596     num = NULL;
1597     if (temp == -1 && PyErr_Occurred())
1598         goto Done;
1599     assert(0 <= temp && temp < 24*3600);
1600     s = (int)temp;
1601 
1602     if (s < 0) {
1603         /* The divisor was positive, so this must be an error. */
1604         assert(PyErr_Occurred());
1605         goto Done;
1606     }
1607 
1608     num = PyTuple_GetItem(tuple, 0);            /* leftover days */
1609     if (num == NULL)
1610         goto Done;
1611     Py_INCREF(num);
1612     temp = PyLong_AsLong(num);
1613     if (temp == -1 && PyErr_Occurred())
1614         goto Done;
1615     d = (int)temp;
1616     if ((long)d != temp) {
1617         PyErr_SetString(PyExc_OverflowError, "normalized days too "
1618                         "large to fit in a C int");
1619         goto Done;
1620     }
1621     result = new_delta_ex(d, s, us, 0, type);
1622 
1623 Done:
1624     Py_XDECREF(tuple);
1625     Py_XDECREF(num);
1626     return result;
1627 }
1628 
1629 #define microseconds_to_delta(pymicros) \
1630     microseconds_to_delta_ex(pymicros, &PyDateTime_DeltaType)
1631 
1632 static PyObject *
1633 multiply_int_timedelta(PyObject *intobj, PyDateTime_Delta *delta)
1634 {
1635     PyObject *pyus_in;
1636     PyObject *pyus_out;
1637     PyObject *result;
1638 
1639     pyus_in = delta_to_microseconds(delta);
1640     if (pyus_in == NULL)
1641         return NULL;
1642 
1643     pyus_out = PyNumber_Multiply(pyus_in, intobj);
1644     Py_DECREF(pyus_in);
1645     if (pyus_out == NULL)
1646         return NULL;
1647 
1648     result = microseconds_to_delta(pyus_out);
1649     Py_DECREF(pyus_out);
1650     return result;
1651 }
1652 
1653 static PyObject *
1654 divide_timedelta_int(PyDateTime_Delta *delta, PyObject *intobj)
1655 {
1656     PyObject *pyus_in;
1657     PyObject *pyus_out;
1658     PyObject *result;
1659 
1660     pyus_in = delta_to_microseconds(delta);
1661     if (pyus_in == NULL)
1662         return NULL;
1663 
1664     pyus_out = PyNumber_FloorDivide(pyus_in, intobj);
1665     Py_DECREF(pyus_in);
1666     if (pyus_out == NULL)
1667         return NULL;
1668 
1669     result = microseconds_to_delta(pyus_out);
1670     Py_DECREF(pyus_out);
1671     return result;
1672 }
1673 
1674 static PyObject *
1675 delta_add(PyObject *left, PyObject *right)
1676 {
1677     PyObject *result = Py_NotImplemented;
1678 
1679     if (PyDelta_Check(left) && PyDelta_Check(right)) {
1680         /* delta + delta */
1681         /* The C-level additions can't overflow because of the
1682          * invariant bounds.
1683          */
1684         int days = GET_TD_DAYS(left) + GET_TD_DAYS(right);
1685         int seconds = GET_TD_SECONDS(left) + GET_TD_SECONDS(right);
1686         int microseconds = GET_TD_MICROSECONDS(left) +
1687                            GET_TD_MICROSECONDS(right);
1688         result = new_delta(days, seconds, microseconds, 1);
1689     }
1690 
1691     if (result == Py_NotImplemented)
1692         Py_INCREF(result);
1693     return result;
1694 }
1695 
1696 static PyObject *
1697 delta_negative(PyDateTime_Delta *self)
1698 {
1699     return new_delta(-GET_TD_DAYS(self),
1700                      -GET_TD_SECONDS(self),
1701                      -GET_TD_MICROSECONDS(self),
1702                      1);
1703 }
1704 
1705 static PyObject *
1706 delta_positive(PyDateTime_Delta *self)
1707 {
1708     /* Could optimize this (by returning self) if this isn't a
1709      * subclass -- but who uses unary + ?  Approximately nobody.
1710      */
1711     return new_delta(GET_TD_DAYS(self),
1712                      GET_TD_SECONDS(self),
1713                      GET_TD_MICROSECONDS(self),
1714                      0);
1715 }
1716 
1717 static PyObject *
1718 delta_abs(PyDateTime_Delta *self)
1719 {
1720     PyObject *result;
1721 
1722     assert(GET_TD_MICROSECONDS(self) >= 0);
1723     assert(GET_TD_SECONDS(self) >= 0);
1724 
1725     if (GET_TD_DAYS(self) < 0)
1726         result = delta_negative(self);
1727     else
1728         result = delta_positive(self);
1729 
1730     return result;
1731 }
1732 
1733 static PyObject *
1734 delta_subtract(PyObject *left, PyObject *right)
1735 {
1736     PyObject *result = Py_NotImplemented;
1737 
1738     if (PyDelta_Check(left) && PyDelta_Check(right)) {
1739         /* delta - delta */
1740         /* The C-level additions can't overflow because of the
1741          * invariant bounds.
1742          */
1743         int days = GET_TD_DAYS(left) - GET_TD_DAYS(right);
1744         int seconds = GET_TD_SECONDS(left) - GET_TD_SECONDS(right);
1745         int microseconds = GET_TD_MICROSECONDS(left) -
1746                            GET_TD_MICROSECONDS(right);
1747         result = new_delta(days, seconds, microseconds, 1);
1748     }
1749 
1750     if (result == Py_NotImplemented)
1751         Py_INCREF(result);
1752     return result;
1753 }
1754 
1755 /* This is more natural as a tp_compare, but doesn't work then:  for whatever
1756  * reason, Python's try_3way_compare ignores tp_compare unless
1757  * PyInstance_Check returns true, but these aren't old-style classes.
1758  */
1759 static PyObject *
1760 delta_richcompare(PyDateTime_Delta *self, PyObject *other, int op)
1761 {
1762     int diff = 42;      /* nonsense */
1763 
1764     if (PyDelta_Check(other)) {
1765         diff = GET_TD_DAYS(self) - GET_TD_DAYS(other);
1766         if (diff == 0) {
1767             diff = GET_TD_SECONDS(self) - GET_TD_SECONDS(other);
1768             if (diff == 0)
1769                 diff = GET_TD_MICROSECONDS(self) -
1770                        GET_TD_MICROSECONDS(other);
1771         }
1772     }
1773     else if (op == Py_EQ || op == Py_NE)
1774         diff = 1;               /* any non-zero value will do */
1775 
1776     else /* stop this from falling back to address comparison */
1777         return cmperror((PyObject *)self, other);
1778 
1779     return diff_to_bool(diff, op);
1780 }
1781 
1782 static PyObject *delta_getstate(PyDateTime_Delta *self);
1783 
1784 static long
1785 delta_hash(PyDateTime_Delta *self)
1786 {
1787     if (self->hashcode == -1) {
1788         PyObject *temp = delta_getstate(self);
1789         if (temp != NULL) {
1790             self->hashcode = PyObject_Hash(temp);
1791             Py_DECREF(temp);
1792         }
1793     }
1794     return self->hashcode;
1795 }
1796 
1797 static PyObject *
1798 delta_multiply(PyObject *left, PyObject *right)
1799 {
1800     PyObject *result = Py_NotImplemented;
1801 
1802     if (PyDelta_Check(left)) {
1803         /* delta * ??? */
1804         if (PyInt_Check(right) || PyLong_Check(right))
1805             result = multiply_int_timedelta(right,
1806                             (PyDateTime_Delta *) left);
1807     }
1808     else if (PyInt_Check(left) || PyLong_Check(left))
1809         result = multiply_int_timedelta(left,
1810                                         (PyDateTime_Delta *) right);
1811 
1812     if (result == Py_NotImplemented)
1813         Py_INCREF(result);
1814     return result;
1815 }
1816 
1817 static PyObject *
1818 delta_divide(PyObject *left, PyObject *right)
1819 {
1820     PyObject *result = Py_NotImplemented;
1821 
1822     if (PyDelta_Check(left)) {
1823         /* delta * ??? */
1824         if (PyInt_Check(right) || PyLong_Check(right))
1825             result = divide_timedelta_int(
1826                             (PyDateTime_Delta *)left,
1827                             right);
1828     }
1829 
1830     if (result == Py_NotImplemented)
1831         Py_INCREF(result);
1832     return result;
1833 }
1834 
1835 /* Fold in the value of the tag ("seconds", "weeks", etc) component of a
1836  * timedelta constructor.  sofar is the # of microseconds accounted for
1837  * so far, and there are factor microseconds per current unit, the number
1838  * of which is given by num.  num * factor is added to sofar in a
1839  * numerically careful way, and that's the result.  Any fractional
1840  * microseconds left over (this can happen if num is a float type) are
1841  * added into *leftover.
1842  * Note that there are many ways this can give an error (NULL) return.
1843  */
1844 static PyObject *
1845 accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor,
1846       double *leftover)
1847 {
1848     PyObject *prod;
1849     PyObject *sum;
1850 
1851     assert(num != NULL);
1852 
1853     if (PyInt_Check(num) || PyLong_Check(num)) {
1854         prod = PyNumber_Multiply(num, factor);
1855         if (prod == NULL)
1856             return NULL;
1857         sum = PyNumber_Add(sofar, prod);
1858         Py_DECREF(prod);
1859         return sum;
1860     }
1861 
1862     if (PyFloat_Check(num)) {
1863         double dnum;
1864         double fracpart;
1865         double intpart;
1866         PyObject *x;
1867         PyObject *y;
1868 
1869         /* The Plan:  decompose num into an integer part and a
1870          * fractional part, num = intpart + fracpart.
1871          * Then num * factor ==
1872          *      intpart * factor + fracpart * factor
1873          * and the LHS can be computed exactly in long arithmetic.
1874          * The RHS is again broken into an int part and frac part.
1875          * and the frac part is added into *leftover.
1876          */
1877         dnum = PyFloat_AsDouble(num);
1878         if (dnum == -1.0 && PyErr_Occurred())
1879             return NULL;
1880         fracpart = modf(dnum, &intpart);
1881         x = PyLong_FromDouble(intpart);
1882         if (x == NULL)
1883             return NULL;
1884 
1885         prod = PyNumber_Multiply(x, factor);
1886         Py_DECREF(x);
1887         if (prod == NULL)
1888             return NULL;
1889 
1890         sum = PyNumber_Add(sofar, prod);
1891         Py_DECREF(prod);
1892         if (sum == NULL)
1893             return NULL;
1894 
1895         if (fracpart == 0.0)
1896             return sum;
1897         /* So far we've lost no information.  Dealing with the
1898          * fractional part requires float arithmetic, and may
1899          * lose a little info.
1900          */
1901         assert(PyInt_Check(factor) || PyLong_Check(factor));
1902         if (PyInt_Check(factor))
1903             dnum = (double)PyInt_AsLong(factor);
1904         else
1905             dnum = PyLong_AsDouble(factor);
1906 
1907         dnum *= fracpart;
1908         fracpart = modf(dnum, &intpart);
1909         x = PyLong_FromDouble(intpart);
1910         if (x == NULL) {
1911             Py_DECREF(sum);
1912             return NULL;
1913         }
1914 
1915         y = PyNumber_Add(sum, x);
1916         Py_DECREF(sum);
1917         Py_DECREF(x);
1918         *leftover += fracpart;
1919         return y;
1920     }
1921 
1922     PyErr_Format(PyExc_TypeError,
1923                  "unsupported type for timedelta %s component: %s",
1924                  tag, Py_TYPE(num)->tp_name);
1925     return NULL;
1926 }
1927 
1928 static PyObject *
1929 delta_new(PyTypeObject *type, PyObject *args, PyObject *kw)
1930 {
1931     PyObject *self = NULL;
1932 
1933     /* Argument objects. */
1934     PyObject *day = NULL;
1935     PyObject *second = NULL;
1936     PyObject *us = NULL;
1937     PyObject *ms = NULL;
1938     PyObject *minute = NULL;
1939     PyObject *hour = NULL;
1940     PyObject *week = NULL;
1941 
1942     PyObject *x = NULL;         /* running sum of microseconds */
1943     PyObject *y = NULL;         /* temp sum of microseconds */
1944     double leftover_us = 0.0;
1945 
1946     static char *keywords[] = {
1947         "days", "seconds", "microseconds", "milliseconds",
1948         "minutes", "hours", "weeks", NULL
1949     };
1950 
1951     if (PyArg_ParseTupleAndKeywords(args, kw, "|OOOOOOO:__new__",
1952                                     keywords,
1953                                     &day, &second, &us,
1954                                     &ms, &minute, &hour, &week) == 0)
1955         goto Done;
1956 
1957     x = PyInt_FromLong(0);
1958     if (x == NULL)
1959         goto Done;
1960 
1961 #define CLEANUP         \
1962     Py_DECREF(x);       \
1963     x = y;              \
1964     if (x == NULL)      \
1965         goto Done
1966 
1967     if (us) {
1968         y = accum("microseconds", x, us, us_per_us, &leftover_us);
1969         CLEANUP;
1970     }
1971     if (ms) {
1972         y = accum("milliseconds", x, ms, us_per_ms, &leftover_us);
1973         CLEANUP;
1974     }
1975     if (second) {
1976         y = accum("seconds", x, second, us_per_second, &leftover_us);
1977         CLEANUP;
1978     }
1979     if (minute) {
1980         y = accum("minutes", x, minute, us_per_minute, &leftover_us);
1981         CLEANUP;
1982     }
1983     if (hour) {
1984         y = accum("hours", x, hour, us_per_hour, &leftover_us);
1985         CLEANUP;
1986     }
1987     if (day) {
1988         y = accum("days", x, day, us_per_day, &leftover_us);
1989         CLEANUP;
1990     }
1991     if (week) {
1992         y = accum("weeks", x, week, us_per_week, &leftover_us);
1993         CLEANUP;
1994     }
1995     if (leftover_us) {
1996         /* Round to nearest whole # of us, and add into x. */
1997         PyObject *temp = PyLong_FromLong(round_to_long(leftover_us));
1998         if (temp == NULL) {
1999             Py_DECREF(x);
2000             goto Done;
2001         }
2002         y = PyNumber_Add(x, temp);
2003         Py_DECREF(temp);
2004         CLEANUP;
2005     }
2006 
2007     self = microseconds_to_delta_ex(x, type);
2008     Py_DECREF(x);
2009 Done:
2010     return self;
2011 
2012 #undef CLEANUP
2013 }
2014 
2015 static int
2016 delta_nonzero(PyDateTime_Delta *self)
2017 {
2018     return (GET_TD_DAYS(self) != 0
2019         || GET_TD_SECONDS(self) != 0
2020         || GET_TD_MICROSECONDS(self) != 0);
2021 }
2022 
2023 static PyObject *
2024 delta_repr(PyDateTime_Delta *self)
2025 {
2026     if (GET_TD_MICROSECONDS(self) != 0)
2027         return PyString_FromFormat("%s(%d, %d, %d)",
2028                                    Py_TYPE(self)->tp_name,
2029                                    GET_TD_DAYS(self),
2030                                    GET_TD_SECONDS(self),
2031                                    GET_TD_MICROSECONDS(self));
2032     if (GET_TD_SECONDS(self) != 0)
2033         return PyString_FromFormat("%s(%d, %d)",
2034                                    Py_TYPE(self)->tp_name,
2035                                    GET_TD_DAYS(self),
2036                                    GET_TD_SECONDS(self));
2037 
2038     return PyString_FromFormat("%s(%d)",
2039                                Py_TYPE(self)->tp_name,
2040                                GET_TD_DAYS(self));
2041 }
2042 
2043 static PyObject *
2044 delta_str(PyDateTime_Delta *self)
2045 {
2046     int days = GET_TD_DAYS(self);
2047     int seconds = GET_TD_SECONDS(self);
2048     int us = GET_TD_MICROSECONDS(self);
2049     int hours;
2050     int minutes;
2051     char buf[100];
2052     char *pbuf = buf;
2053     size_t buflen = sizeof(buf);
2054     int n;
2055 
2056     minutes = divmod(seconds, 60, &seconds);
2057     hours = divmod(minutes, 60, &minutes);
2058 
2059     if (days) {
2060         n = PyOS_snprintf(pbuf, buflen, "%d day%s, ", days,
2061                           (days == 1 || days == -1) ? "" : "s");
2062         if (n < 0 || (size_t)n >= buflen)
2063             goto Fail;
2064         pbuf += n;
2065         buflen -= (size_t)n;
2066     }
2067 
2068     n = PyOS_snprintf(pbuf, buflen, "%d:%02d:%02d",
2069                       hours, minutes, seconds);
2070     if (n < 0 || (size_t)n >= buflen)
2071         goto Fail;
2072     pbuf += n;
2073     buflen -= (size_t)n;
2074 
2075     if (us) {
2076         n = PyOS_snprintf(pbuf, buflen, ".%06d", us);
2077         if (n < 0 || (size_t)n >= buflen)
2078             goto Fail;
2079         pbuf += n;
2080     }
2081 
2082     return PyString_FromStringAndSize(buf, pbuf - buf);
2083 
2084  Fail:
2085     PyErr_SetString(PyExc_SystemError, "goofy result from PyOS_snprintf");
2086     return NULL;
2087 }
2088 
2089 /* Pickle support, a simple use of __reduce__. */
2090 
2091 /* __getstate__ isn't exposed */
2092 static PyObject *
2093 delta_getstate(PyDateTime_Delta *self)
2094 {
2095     return Py_BuildValue("iii", GET_TD_DAYS(self),
2096                                 GET_TD_SECONDS(self),
2097                                 GET_TD_MICROSECONDS(self));
2098 }
2099 
2100 static PyObject *
2101 delta_total_seconds(PyObject *self)
2102 {
2103     PyObject *total_seconds;
2104     PyObject *total_microseconds;
2105     PyObject *one_million;
2106 
2107     total_microseconds = delta_to_microseconds((PyDateTime_Delta *)self);
2108     if (total_microseconds == NULL)
2109         return NULL;
2110 
2111     one_million = PyLong_FromLong(1000000L);
2112     if (one_million == NULL) {
2113         Py_DECREF(total_microseconds);
2114         return NULL;
2115     }
2116 
2117     total_seconds = PyNumber_TrueDivide(total_microseconds, one_million);
2118 
2119     Py_DECREF(total_microseconds);
2120     Py_DECREF(one_million);
2121     return total_seconds;
2122 }
2123 
2124 static PyObject *
2125 delta_reduce(PyDateTime_Delta* self)
2126 {
2127     return Py_BuildValue("ON", Py_TYPE(self), delta_getstate(self));
2128 }
2129 
2130 #define OFFSET(field)  offsetof(PyDateTime_Delta, field)
2131 
2132 static PyMemberDef delta_members[] = {
2133 
2134     {"days",         T_INT, OFFSET(days),         READONLY,
2135      PyDoc_STR("Number of days.")},
2136 
2137     {"seconds",      T_INT, OFFSET(seconds),      READONLY,
2138      PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")},
2139 
2140     {"microseconds", T_INT, OFFSET(microseconds), READONLY,
2141      PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")},
2142     {NULL}
2143 };
2144 
2145 static PyMethodDef delta_methods[] = {
2146     {"total_seconds", (PyCFunction)delta_total_seconds, METH_NOARGS,
2147      PyDoc_STR("Total seconds in the duration.")},
2148 
2149     {"__reduce__", (PyCFunction)delta_reduce, METH_NOARGS,
2150      PyDoc_STR("__reduce__() -> (cls, state)")},
2151 
2152     {NULL,      NULL},
2153 };
2154 
2155 static char delta_doc[] =
2156 PyDoc_STR("Difference between two datetime values.");
2157 
2158 static PyNumberMethods delta_as_number = {
2159     delta_add,                                  /* nb_add */
2160     delta_subtract,                             /* nb_subtract */
2161     delta_multiply,                             /* nb_multiply */
2162     delta_divide,                               /* nb_divide */
2163     0,                                          /* nb_remainder */
2164     0,                                          /* nb_divmod */
2165     0,                                          /* nb_power */
2166     (unaryfunc)delta_negative,                  /* nb_negative */
2167     (unaryfunc)delta_positive,                  /* nb_positive */
2168     (unaryfunc)delta_abs,                       /* nb_absolute */
2169     (inquiry)delta_nonzero,                     /* nb_nonzero */
2170     0,                                          /*nb_invert*/
2171     0,                                          /*nb_lshift*/
2172     0,                                          /*nb_rshift*/
2173     0,                                          /*nb_and*/
2174     0,                                          /*nb_xor*/
2175     0,                                          /*nb_or*/
2176     0,                                          /*nb_coerce*/
2177     0,                                          /*nb_int*/
2178     0,                                          /*nb_long*/
2179     0,                                          /*nb_float*/
2180     0,                                          /*nb_oct*/
2181     0,                                          /*nb_hex*/
2182     0,                                          /*nb_inplace_add*/
2183     0,                                          /*nb_inplace_subtract*/
2184     0,                                          /*nb_inplace_multiply*/
2185     0,                                          /*nb_inplace_divide*/
2186     0,                                          /*nb_inplace_remainder*/
2187     0,                                          /*nb_inplace_power*/
2188     0,                                          /*nb_inplace_lshift*/
2189     0,                                          /*nb_inplace_rshift*/
2190     0,                                          /*nb_inplace_and*/
2191     0,                                          /*nb_inplace_xor*/
2192     0,                                          /*nb_inplace_or*/
2193     delta_divide,                               /* nb_floor_divide */
2194     0,                                          /* nb_true_divide */
2195     0,                                          /* nb_inplace_floor_divide */
2196     0,                                          /* nb_inplace_true_divide */
2197 };
2198 
2199 static PyTypeObject PyDateTime_DeltaType = {
2200     PyVarObject_HEAD_INIT(NULL, 0)
2201     "datetime.timedelta",                               /* tp_name */
2202     sizeof(PyDateTime_Delta),                           /* tp_basicsize */
2203     0,                                                  /* tp_itemsize */
2204     0,                                                  /* tp_dealloc */
2205     0,                                                  /* tp_print */
2206     0,                                                  /* tp_getattr */
2207     0,                                                  /* tp_setattr */
2208     0,                                                  /* tp_compare */
2209     (reprfunc)delta_repr,                               /* tp_repr */
2210     &delta_as_number,                                   /* tp_as_number */
2211     0,                                                  /* tp_as_sequence */
2212     0,                                                  /* tp_as_mapping */
2213     (hashfunc)delta_hash,                               /* tp_hash */
2214     0,                                                  /* tp_call */
2215     (reprfunc)delta_str,                                /* tp_str */
2216     PyObject_GenericGetAttr,                            /* tp_getattro */
2217     0,                                                  /* tp_setattro */
2218     0,                                                  /* tp_as_buffer */
2219     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
2220         Py_TPFLAGS_BASETYPE,                            /* tp_flags */
2221     delta_doc,                                          /* tp_doc */
2222     0,                                                  /* tp_traverse */
2223     0,                                                  /* tp_clear */
2224     (richcmpfunc)delta_richcompare,                     /* tp_richcompare */
2225     0,                                                  /* tp_weaklistoffset */
2226     0,                                                  /* tp_iter */
2227     0,                                                  /* tp_iternext */
2228     delta_methods,                                      /* tp_methods */
2229     delta_members,                                      /* tp_members */
2230     0,                                                  /* tp_getset */
2231     0,                                                  /* tp_base */
2232     0,                                                  /* tp_dict */
2233     0,                                                  /* tp_descr_get */
2234     0,                                                  /* tp_descr_set */
2235     0,                                                  /* tp_dictoffset */
2236     0,                                                  /* tp_init */
2237     0,                                                  /* tp_alloc */
2238     delta_new,                                          /* tp_new */
2239     0,                                                  /* tp_free */
2240 };
2241 
2242 /*
2243  * PyDateTime_Date implementation.
2244  */
2245 
2246 /* Accessor properties. */
2247 
2248 static PyObject *
2249 date_year(PyDateTime_Date *self, void *unused)
2250 {
2251     return PyInt_FromLong(GET_YEAR(self));
2252 }
2253 
2254 static PyObject *
2255 date_month(PyDateTime_Date *self, void *unused)
2256 {
2257     return PyInt_FromLong(GET_MONTH(self));
2258 }
2259 
2260 static PyObject *
2261 date_day(PyDateTime_Date *self, void *unused)
2262 {
2263     return PyInt_FromLong(GET_DAY(self));
2264 }
2265 
2266 static PyGetSetDef date_getset[] = {
2267     {"year",        (getter)date_year},
2268     {"month",       (getter)date_month},
2269     {"day",         (getter)date_day},
2270     {NULL}
2271 };
2272 
2273 /* Constructors. */
2274 
2275 static char *date_kws[] = {"year", "month", "day", NULL};
2276 
2277 static PyObject *
2278 date_new(PyTypeObject *type, PyObject *args, PyObject *kw)
2279 {
2280     PyObject *self = NULL;
2281     PyObject *state;
2282     int year;
2283     int month;
2284     int day;
2285 
2286     /* Check for invocation from pickle with __getstate__ state */
2287     if (PyTuple_GET_SIZE(args) == 1 &&
2288         PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
2289         PyString_GET_SIZE(state) == _PyDateTime_DATE_DATASIZE &&
2290         MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
2291     {
2292         PyDateTime_Date *me;
2293 
2294         me = (PyDateTime_Date *) (type->tp_alloc(type, 0));
2295         if (me != NULL) {
2296             char *pdata = PyString_AS_STRING(state);
2297             memcpy(me->data, pdata, _PyDateTime_DATE_DATASIZE);
2298             me->hashcode = -1;
2299         }
2300         return (PyObject *)me;
2301     }
2302 
2303     if (PyArg_ParseTupleAndKeywords(args, kw, "iii", date_kws,
2304                                     &year, &month, &day)) {
2305         if (check_date_args(year, month, day) < 0)
2306             return NULL;
2307         self = new_date_ex(year, month, day, type);
2308     }
2309     return self;
2310 }
2311 
2312 /* Return new date from localtime(t). */
2313 static PyObject *
2314 date_local_from_time_t(PyObject *cls, double ts)
2315 {
2316     struct tm *tm;
2317     time_t t;
2318     PyObject *result = NULL;
2319 
2320     t = _PyTime_DoubleToTimet(ts);
2321     if (t == (time_t)-1 && PyErr_Occurred())
2322         return NULL;
2323     tm = localtime(&t);
2324     if (tm)
2325         result = PyObject_CallFunction(cls, "iii",
2326                                        tm->tm_year + 1900,
2327                                        tm->tm_mon + 1,
2328                                        tm->tm_mday);
2329     else
2330         PyErr_SetString(PyExc_ValueError,
2331                         "timestamp out of range for "
2332                         "platform localtime() function");
2333     return result;
2334 }
2335 
2336 /* Return new date from current time.
2337  * We say this is equivalent to fromtimestamp(time.time()), and the
2338  * only way to be sure of that is to *call* time.time().  That's not
2339  * generally the same as calling C's time.
2340  */
2341 static PyObject *
2342 date_today(PyObject *cls, PyObject *dummy)
2343 {
2344     PyObject *time;
2345     PyObject *result;
2346 
2347     time = time_time();
2348     if (time == NULL)
2349         return NULL;
2350 
2351     /* Note well:  today() is a class method, so this may not call
2352      * date.fromtimestamp.  For example, it may call
2353      * datetime.fromtimestamp.  That's why we need all the accuracy
2354      * time.time() delivers; if someone were gonzo about optimization,
2355      * date.today() could get away with plain C time().
2356      */
2357     result = PyObject_CallMethod(cls, "fromtimestamp", "O", time);
2358     Py_DECREF(time);
2359     return result;
2360 }
2361 
2362 /* Return new date from given timestamp (Python timestamp -- a double). */
2363 static PyObject *
2364 date_fromtimestamp(PyObject *cls, PyObject *args)
2365 {
2366     double timestamp;
2367     PyObject *result = NULL;
2368 
2369     if (PyArg_ParseTuple(args, "d:fromtimestamp", &timestamp))
2370         result = date_local_from_time_t(cls, timestamp);
2371     return result;
2372 }
2373 
2374 /* Return new date from proleptic Gregorian ordinal.  Raises ValueError if
2375  * the ordinal is out of range.
2376  */
2377 static PyObject *
2378 date_fromordinal(PyObject *cls, PyObject *args)
2379 {
2380     PyObject *result = NULL;
2381     int ordinal;
2382 
2383     if (PyArg_ParseTuple(args, "i:fromordinal", &ordinal)) {
2384         int year;
2385         int month;
2386         int day;
2387 
2388         if (ordinal < 1)
2389             PyErr_SetString(PyExc_ValueError, "ordinal must be "
2390                                               ">= 1");
2391         else {
2392             ord_to_ymd(ordinal, &year, &month, &day);
2393             result = PyObject_CallFunction(cls, "iii",
2394                                            year, month, day);
2395         }
2396     }
2397     return result;
2398 }
2399 
2400 /*
2401  * Date arithmetic.
2402  */
2403 
2404 /* date + timedelta -> date.  If arg negate is true, subtract the timedelta
2405  * instead.
2406  */
2407 static PyObject *
2408 add_date_timedelta(PyDateTime_Date *date, PyDateTime_Delta *delta, int negate)
2409 {
2410     PyObject *result = NULL;
2411     int year = GET_YEAR(date);
2412     int month = GET_MONTH(date);
2413     int deltadays = GET_TD_DAYS(delta);
2414     /* C-level overflow is impossible because |deltadays| < 1e9. */
2415     int day = GET_DAY(date) + (negate ? -deltadays : deltadays);
2416 
2417     if (normalize_date(&year, &month, &day) >= 0)
2418         result = new_date(year, month, day);
2419     return result;
2420 }
2421 
2422 static PyObject *
2423 date_add(PyObject *left, PyObject *right)
2424 {
2425     if (PyDateTime_Check(left) || PyDateTime_Check(right)) {
2426         Py_INCREF(Py_NotImplemented);
2427         return Py_NotImplemented;
2428     }
2429     if (PyDate_Check(left)) {
2430         /* date + ??? */
2431         if (PyDelta_Check(right))
2432             /* date + delta */
2433             return add_date_timedelta((PyDateTime_Date *) left,
2434                                       (PyDateTime_Delta *) right,
2435                                       0);
2436     }
2437     else {
2438         /* ??? + date
2439          * 'right' must be one of us, or we wouldn't have been called
2440          */
2441         if (PyDelta_Check(left))
2442             /* delta + date */
2443             return add_date_timedelta((PyDateTime_Date *) right,
2444                                       (PyDateTime_Delta *) left,
2445                                       0);
2446     }
2447     Py_INCREF(Py_NotImplemented);
2448     return Py_NotImplemented;
2449 }
2450 
2451 static PyObject *
2452 date_subtract(PyObject *left, PyObject *right)
2453 {
2454     if (PyDateTime_Check(left) || PyDateTime_Check(right)) {
2455         Py_INCREF(Py_NotImplemented);
2456         return Py_NotImplemented;
2457     }
2458     if (PyDate_Check(left)) {
2459         if (PyDate_Check(right)) {
2460             /* date - date */
2461             int left_ord = ymd_to_ord(GET_YEAR(left),
2462                                       GET_MONTH(left),
2463                                       GET_DAY(left));
2464             int right_ord = ymd_to_ord(GET_YEAR(right),
2465                                        GET_MONTH(right),
2466                                        GET_DAY(right));
2467             return new_delta(left_ord - right_ord, 0, 0, 0);
2468         }
2469         if (PyDelta_Check(right)) {
2470             /* date - delta */
2471             return add_date_timedelta((PyDateTime_Date *) left,
2472                                       (PyDateTime_Delta *) right,
2473                                       1);
2474         }
2475     }
2476     Py_INCREF(Py_NotImplemented);
2477     return Py_NotImplemented;
2478 }
2479 
2480 
2481 /* Various ways to turn a date into a string. */
2482 
2483 static PyObject *
2484 date_repr(PyDateTime_Date *self)
2485 {
2486     char buffer[1028];
2487     const char *type_name;
2488 
2489     type_name = Py_TYPE(self)->tp_name;
2490     PyOS_snprintf(buffer, sizeof(buffer), "%s(%d, %d, %d)",
2491                   type_name,
2492                   GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
2493 
2494     return PyString_FromString(buffer);
2495 }
2496 
2497 static PyObject *
2498 date_isoformat(PyDateTime_Date *self)
2499 {
2500     char buffer[128];
2501 
2502     isoformat_date(self, buffer, sizeof(buffer));
2503     return PyString_FromString(buffer);
2504 }
2505 
2506 /* str() calls the appropriate isoformat() method. */
2507 static PyObject *
2508 date_str(PyDateTime_Date *self)
2509 {
2510     return PyObject_CallMethod((PyObject *)self, "isoformat", "()");
2511 }
2512 
2513 
2514 static PyObject *
2515 date_ctime(PyDateTime_Date *self)
2516 {
2517     return format_ctime(self, 0, 0, 0);
2518 }
2519 
2520 static PyObject *
2521 date_strftime(PyDateTime_Date *self, PyObject *args, PyObject *kw)
2522 {
2523     /* This method can be inherited, and needs to call the
2524      * timetuple() method appropriate to self's class.
2525      */
2526     PyObject *result;
2527     PyObject *tuple;
2528     const char *format;
2529     Py_ssize_t format_len;
2530     static char *keywords[] = {"format", NULL};
2531 
2532     if (! PyArg_ParseTupleAndKeywords(args, kw, "s#:strftime", keywords,
2533                                       &format, &format_len))
2534         return NULL;
2535 
2536     tuple = PyObject_CallMethod((PyObject *)self, "timetuple", "()");
2537     if (tuple == NULL)
2538         return NULL;
2539     result = wrap_strftime((PyObject *)self, format, format_len, tuple,
2540                            (PyObject *)self);
2541     Py_DECREF(tuple);
2542     return result;
2543 }
2544 
2545 static PyObject *
2546 date_format(PyDateTime_Date *self, PyObject *args)
2547 {
2548     PyObject *format;
2549 
2550     if (!PyArg_ParseTuple(args, "O:__format__", &format))
2551         return NULL;
2552 
2553     /* Check for str or unicode */
2554     if (PyString_Check(format)) {
2555         /* If format is zero length, return str(self) */
2556         if (PyString_GET_SIZE(format) == 0)
2557             return PyObject_Str((PyObject *)self);
2558     } else if (PyUnicode_Check(format)) {
2559         /* If format is zero length, return str(self) */
2560         if (PyUnicode_GET_SIZE(format) == 0)
2561             return PyObject_Unicode((PyObject *)self);
2562     } else {
2563         PyErr_Format(PyExc_ValueError,
2564                      "__format__ expects str or unicode, not %.200s",
2565                      Py_TYPE(format)->tp_name);
2566         return NULL;
2567     }
2568     return PyObject_CallMethod((PyObject *)self, "strftime", "O", format);
2569 }
2570 
2571 /* ISO methods. */
2572 
2573 static PyObject *
2574 date_isoweekday(PyDateTime_Date *self)
2575 {
2576     int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
2577 
2578     return PyInt_FromLong(dow + 1);
2579 }
2580 
2581 static PyObject *
2582 date_isocalendar(PyDateTime_Date *self)
2583 {
2584     int  year         = GET_YEAR(self);
2585     int  week1_monday = iso_week1_monday(year);
2586     int today         = ymd_to_ord(year, GET_MONTH(self), GET_DAY(self));
2587     int  week;
2588     int  day;
2589 
2590     week = divmod(today - week1_monday, 7, &day);
2591     if (week < 0) {
2592         --year;
2593         week1_monday = iso_week1_monday(year);
2594         week = divmod(today - week1_monday, 7, &day);
2595     }
2596     else if (week >= 52 && today >= iso_week1_monday(year + 1)) {
2597         ++year;
2598         week = 0;
2599     }
2600     return Py_BuildValue("iii", year, week + 1, day + 1);
2601 }
2602 
2603 /* Miscellaneous methods. */
2604 
2605 /* This is more natural as a tp_compare, but doesn't work then:  for whatever
2606  * reason, Python's try_3way_compare ignores tp_compare unless
2607  * PyInstance_Check returns true, but these aren't old-style classes.
2608  */
2609 static PyObject *
2610 date_richcompare(PyDateTime_Date *self, PyObject *other, int op)
2611 {
2612     int diff = 42;      /* nonsense */
2613 
2614     if (PyDate_Check(other))
2615         diff = memcmp(self->data, ((PyDateTime_Date *)other)->data,
2616                       _PyDateTime_DATE_DATASIZE);
2617 
2618     else if (PyObject_HasAttrString(other, "timetuple")) {
2619         /* A hook for other kinds of date objects. */
2620         Py_INCREF(Py_NotImplemented);
2621         return Py_NotImplemented;
2622     }
2623     else if (op == Py_EQ || op == Py_NE)
2624         diff = 1;               /* any non-zero value will do */
2625 
2626     else /* stop this from falling back to address comparison */
2627         return cmperror((PyObject *)self, other);
2628 
2629     return diff_to_bool(diff, op);
2630 }
2631 
2632 static PyObject *
2633 date_timetuple(PyDateTime_Date *self)
2634 {
2635     return build_struct_time(GET_YEAR(self),
2636                              GET_MONTH(self),
2637                              GET_DAY(self),
2638                              0, 0, 0, -1);
2639 }
2640 
2641 static PyObject *
2642 date_replace(PyDateTime_Date *self, PyObject *args, PyObject *kw)
2643 {
2644     PyObject *clone;
2645     PyObject *tuple;
2646     int year = GET_YEAR(self);
2647     int month = GET_MONTH(self);
2648     int day = GET_DAY(self);
2649 
2650     if (! PyArg_ParseTupleAndKeywords(args, kw, "|iii:replace", date_kws,
2651                                       &year, &month, &day))
2652         return NULL;
2653     tuple = Py_BuildValue("iii", year, month, day);
2654     if (tuple == NULL)
2655         return NULL;
2656     clone = date_new(Py_TYPE(self), tuple, NULL);
2657     Py_DECREF(tuple);
2658     return clone;
2659 }
2660 
2661 static PyObject *date_getstate(PyDateTime_Date *self);
2662 
2663 static long
2664 date_hash(PyDateTime_Date *self)
2665 {
2666     if (self->hashcode == -1) {
2667         PyObject *temp = date_getstate(self);
2668         if (temp != NULL) {
2669             self->hashcode = PyObject_Hash(temp);
2670             Py_DECREF(temp);
2671         }
2672     }
2673     return self->hashcode;
2674 }
2675 
2676 static PyObject *
2677 date_toordinal(PyDateTime_Date *self)
2678 {
2679     return PyInt_FromLong(ymd_to_ord(GET_YEAR(self), GET_MONTH(self),
2680                                      GET_DAY(self)));
2681 }
2682 
2683 static PyObject *
2684 date_weekday(PyDateTime_Date *self)
2685 {
2686     int dow = weekday(GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
2687 
2688     return PyInt_FromLong(dow);
2689 }
2690 
2691 /* Pickle support, a simple use of __reduce__. */
2692 
2693 /* __getstate__ isn't exposed */
2694 static PyObject *
2695 date_getstate(PyDateTime_Date *self)
2696 {
2697     return Py_BuildValue(
2698         "(N)",
2699         PyString_FromStringAndSize((char *)self->data,
2700                                    _PyDateTime_DATE_DATASIZE));
2701 }
2702 
2703 static PyObject *
2704 date_reduce(PyDateTime_Date *self, PyObject *arg)
2705 {
2706     return Py_BuildValue("(ON)", Py_TYPE(self), date_getstate(self));
2707 }
2708 
2709 static PyMethodDef date_methods[] = {
2710 
2711     /* Class methods: */
2712 
2713     {"fromtimestamp", (PyCFunction)date_fromtimestamp, METH_VARARGS |
2714                                                        METH_CLASS,
2715      PyDoc_STR("timestamp -> local date from a POSIX timestamp (like "
2716                "time.time()).")},
2717 
2718     {"fromordinal", (PyCFunction)date_fromordinal,      METH_VARARGS |
2719                                                     METH_CLASS,
2720      PyDoc_STR("int -> date corresponding to a proleptic Gregorian "
2721                "ordinal.")},
2722 
2723     {"today",         (PyCFunction)date_today,   METH_NOARGS | METH_CLASS,
2724      PyDoc_STR("Current date or datetime:  same as "
2725                "self.__class__.fromtimestamp(time.time()).")},
2726 
2727     /* Instance methods: */
2728 
2729     {"ctime",       (PyCFunction)date_ctime,        METH_NOARGS,
2730      PyDoc_STR("Return ctime() style string.")},
2731 
2732     {"strftime",        (PyCFunction)date_strftime,     METH_VARARGS | METH_KEYWORDS,
2733      PyDoc_STR("format -> strftime() style string.")},
2734 
2735     {"__format__",      (PyCFunction)date_format,       METH_VARARGS,
2736      PyDoc_STR("Formats self with strftime.")},
2737 
2738     {"timetuple",   (PyCFunction)date_timetuple,    METH_NOARGS,
2739      PyDoc_STR("Return time tuple, compatible with time.localtime().")},
2740 
2741     {"isocalendar", (PyCFunction)date_isocalendar,  METH_NOARGS,
2742      PyDoc_STR("Return a 3-tuple containing ISO year, week number, and "
2743                "weekday.")},
2744 
2745     {"isoformat",   (PyCFunction)date_isoformat,        METH_NOARGS,
2746      PyDoc_STR("Return string in ISO 8601 format, YYYY-MM-DD.")},
2747 
2748     {"isoweekday",  (PyCFunction)date_isoweekday,   METH_NOARGS,
2749      PyDoc_STR("Return the day of the week represented by the date.\n"
2750                "Monday == 1 ... Sunday == 7")},
2751 
2752     {"toordinal",   (PyCFunction)date_toordinal,    METH_NOARGS,
2753      PyDoc_STR("Return proleptic Gregorian ordinal.  January 1 of year "
2754                "1 is day 1.")},
2755 
2756     {"weekday",     (PyCFunction)date_weekday,      METH_NOARGS,
2757      PyDoc_STR("Return the day of the week represented by the date.\n"
2758                "Monday == 0 ... Sunday == 6")},
2759 
2760     {"replace",     (PyCFunction)date_replace,      METH_VARARGS | METH_KEYWORDS,
2761      PyDoc_STR("Return date with new specified fields.")},
2762 
2763     {"__reduce__", (PyCFunction)date_reduce,        METH_NOARGS,
2764      PyDoc_STR("__reduce__() -> (cls, state)")},
2765 
2766     {NULL,      NULL}
2767 };
2768 
2769 static char date_doc[] =
2770 PyDoc_STR("date(year, month, day) --> date object");
2771 
2772 static PyNumberMethods date_as_number = {
2773     date_add,                                           /* nb_add */
2774     date_subtract,                                      /* nb_subtract */
2775     0,                                                  /* nb_multiply */
2776     0,                                                  /* nb_divide */
2777     0,                                                  /* nb_remainder */
2778     0,                                                  /* nb_divmod */
2779     0,                                                  /* nb_power */
2780     0,                                                  /* nb_negative */
2781     0,                                                  /* nb_positive */
2782     0,                                                  /* nb_absolute */
2783     0,                                                  /* nb_nonzero */
2784 };
2785 
2786 static PyTypeObject PyDateTime_DateType = {
2787     PyVarObject_HEAD_INIT(NULL, 0)
2788     "datetime.date",                                    /* tp_name */
2789     sizeof(PyDateTime_Date),                            /* tp_basicsize */
2790     0,                                                  /* tp_itemsize */
2791     0,                                                  /* tp_dealloc */
2792     0,                                                  /* tp_print */
2793     0,                                                  /* tp_getattr */
2794     0,                                                  /* tp_setattr */
2795     0,                                                  /* tp_compare */
2796     (reprfunc)date_repr,                                /* tp_repr */
2797     &date_as_number,                                    /* tp_as_number */
2798     0,                                                  /* tp_as_sequence */
2799     0,                                                  /* tp_as_mapping */
2800     (hashfunc)date_hash,                                /* tp_hash */
2801     0,                                                  /* tp_call */
2802     (reprfunc)date_str,                                 /* tp_str */
2803     PyObject_GenericGetAttr,                            /* tp_getattro */
2804     0,                                                  /* tp_setattro */
2805     0,                                                  /* tp_as_buffer */
2806     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
2807     Py_TPFLAGS_BASETYPE,                                /* tp_flags */
2808     date_doc,                                           /* tp_doc */
2809     0,                                                  /* tp_traverse */
2810     0,                                                  /* tp_clear */
2811     (richcmpfunc)date_richcompare,                      /* tp_richcompare */
2812     0,                                                  /* tp_weaklistoffset */
2813     0,                                                  /* tp_iter */
2814     0,                                                  /* tp_iternext */
2815     date_methods,                                       /* tp_methods */
2816     0,                                                  /* tp_members */
2817     date_getset,                                        /* tp_getset */
2818     0,                                                  /* tp_base */
2819     0,                                                  /* tp_dict */
2820     0,                                                  /* tp_descr_get */
2821     0,                                                  /* tp_descr_set */
2822     0,                                                  /* tp_dictoffset */
2823     0,                                                  /* tp_init */
2824     0,                                                  /* tp_alloc */
2825     date_new,                                           /* tp_new */
2826     0,                                                  /* tp_free */
2827 };
2828 
2829 /*
2830  * PyDateTime_TZInfo implementation.
2831  */
2832 
2833 /* This is a pure abstract base class, so doesn't do anything beyond
2834  * raising NotImplemented exceptions.  Real tzinfo classes need
2835  * to derive from this.  This is mostly for clarity, and for efficiency in
2836  * datetime and time constructors (their tzinfo arguments need to
2837  * be subclasses of this tzinfo class, which is easy and quick to check).
2838  *
2839  * Note:  For reasons having to do with pickling of subclasses, we have
2840  * to allow tzinfo objects to be instantiated.  This wasn't an issue
2841  * in the Python implementation (__init__() could raise NotImplementedError
2842  * there without ill effect), but doing so in the C implementation hit a
2843  * brick wall.
2844  */
2845 
2846 static PyObject *
2847 tzinfo_nogo(const char* methodname)
2848 {
2849     PyErr_Format(PyExc_NotImplementedError,
2850                  "a tzinfo subclass must implement %s()",
2851                  methodname);
2852     return NULL;
2853 }
2854 
2855 /* Methods.  A subclass must implement these. */
2856 
2857 static PyObject *
2858 tzinfo_tzname(PyDateTime_TZInfo *self, PyObject *dt)
2859 {
2860     return tzinfo_nogo("tzname");
2861 }
2862 
2863 static PyObject *
2864 tzinfo_utcoffset(PyDateTime_TZInfo *self, PyObject *dt)
2865 {
2866     return tzinfo_nogo("utcoffset");
2867 }
2868 
2869 static PyObject *
2870 tzinfo_dst(PyDateTime_TZInfo *self, PyObject *dt)
2871 {
2872     return tzinfo_nogo("dst");
2873 }
2874 
2875 static PyObject *
2876 tzinfo_fromutc(PyDateTime_TZInfo *self, PyDateTime_DateTime *dt)
2877 {
2878     int y, m, d, hh, mm, ss, us;
2879 
2880     PyObject *result;
2881     int off, dst;
2882     int none;
2883     int delta;
2884 
2885     if (! PyDateTime_Check(dt)) {
2886         PyErr_SetString(PyExc_TypeError,
2887                         "fromutc: argument must be a datetime");
2888         return NULL;
2889     }
2890     if (! HASTZINFO(dt) || dt->tzinfo != (PyObject *)self) {
2891         PyErr_SetString(PyExc_ValueError, "fromutc: dt.tzinfo "
2892                         "is not self");
2893         return NULL;
2894     }
2895 
2896     off = call_utcoffset(dt->tzinfo, (PyObject *)dt, &none);
2897     if (off == -1 && PyErr_Occurred())
2898         return NULL;
2899     if (none) {
2900         PyErr_SetString(PyExc_ValueError, "fromutc: non-None "
2901                         "utcoffset() result required");
2902         return NULL;
2903     }
2904 
2905     dst = call_dst(dt->tzinfo, (PyObject *)dt, &none);
2906     if (dst == -1 && PyErr_Occurred())
2907         return NULL;
2908     if (none) {
2909         PyErr_SetString(PyExc_ValueError, "fromutc: non-None "
2910                         "dst() result required");
2911         return NULL;
2912     }
2913 
2914     y = GET_YEAR(dt);
2915     m = GET_MONTH(dt);
2916     d = GET_DAY(dt);
2917     hh = DATE_GET_HOUR(dt);
2918     mm = DATE_GET_MINUTE(dt);
2919     ss = DATE_GET_SECOND(dt);
2920     us = DATE_GET_MICROSECOND(dt);
2921 
2922     delta = off - dst;
2923     mm += delta;
2924     if ((mm < 0 || mm >= 60) &&
2925         normalize_datetime(&y, &m, &d, &hh, &mm, &ss, &us) < 0)
2926         return NULL;
2927     result = new_datetime(y, m, d, hh, mm, ss, us, dt->tzinfo);
2928     if (result == NULL)
2929         return result;
2930 
2931     dst = call_dst(dt->tzinfo, result, &none);
2932     if (dst == -1 && PyErr_Occurred())
2933         goto Fail;
2934     if (none)
2935         goto Inconsistent;
2936     if (dst == 0)
2937         return result;
2938 
2939     mm += dst;
2940     if ((mm < 0 || mm >= 60) &&
2941         normalize_datetime(&y, &m, &d, &hh, &mm, &ss, &us) < 0)
2942         goto Fail;
2943     Py_DECREF(result);
2944     result = new_datetime(y, m, d, hh, mm, ss, us, dt->tzinfo);
2945     return result;
2946 
2947 Inconsistent:
2948     PyErr_SetString(PyExc_ValueError, "fromutc: tz.dst() gave"
2949                     "inconsistent results; cannot convert");
2950 
2951     /* fall thru to failure */
2952 Fail:
2953     Py_DECREF(result);
2954     return NULL;
2955 }
2956 
2957 /*
2958  * Pickle support.  This is solely so that tzinfo subclasses can use
2959  * pickling -- tzinfo itself is supposed to be uninstantiable.
2960  */
2961 
2962 static PyObject *
2963 tzinfo_reduce(PyObject *self)
2964 {
2965     PyObject *args, *state, *tmp;
2966     PyObject *getinitargs, *getstate;
2967 
2968     tmp = PyTuple_New(0);
2969     if (tmp == NULL)
2970         return NULL;
2971 
2972     getinitargs = PyObject_GetAttrString(self, "__getinitargs__");
2973     if (getinitargs != NULL) {
2974         args = PyObject_CallObject(getinitargs, tmp);
2975         Py_DECREF(getinitargs);
2976         if (args == NULL) {
2977             Py_DECREF(tmp);
2978             return NULL;
2979         }
2980     }
2981     else {
2982         PyErr_Clear();
2983         args = tmp;
2984         Py_INCREF(args);
2985     }
2986 
2987     getstate = PyObject_GetAttrString(self, "__getstate__");
2988     if (getstate != NULL) {
2989         state = PyObject_CallObject(getstate, tmp);
2990         Py_DECREF(getstate);
2991         if (state == NULL) {
2992             Py_DECREF(args);
2993             Py_DECREF(tmp);
2994             return NULL;
2995         }
2996     }
2997     else {
2998         PyObject **dictptr;
2999         PyErr_Clear();
3000         state = Py_None;
3001         dictptr = _PyObject_GetDictPtr(self);
3002         if (dictptr && *dictptr && PyDict_Size(*dictptr))
3003             state = *dictptr;
3004         Py_INCREF(state);
3005     }
3006 
3007     Py_DECREF(tmp);
3008 
3009     if (state == Py_None) {
3010         Py_DECREF(state);
3011         return Py_BuildValue("(ON)", Py_TYPE(self), args);
3012     }
3013     else
3014         return Py_BuildValue("(ONN)", Py_TYPE(self), args, state);
3015 }
3016 
3017 static PyMethodDef tzinfo_methods[] = {
3018 
3019     {"tzname",          (PyCFunction)tzinfo_tzname,             METH_O,
3020      PyDoc_STR("datetime -> string name of time zone.")},
3021 
3022     {"utcoffset",       (PyCFunction)tzinfo_utcoffset,          METH_O,
3023      PyDoc_STR("datetime -> minutes east of UTC (negative for "
3024                "west of UTC).")},
3025 
3026     {"dst",             (PyCFunction)tzinfo_dst,                METH_O,
3027      PyDoc_STR("datetime -> DST offset in minutes east of UTC.")},
3028 
3029     {"fromutc",         (PyCFunction)tzinfo_fromutc,            METH_O,
3030      PyDoc_STR("datetime in UTC -> datetime in local time.")},
3031 
3032     {"__reduce__",  (PyCFunction)tzinfo_reduce,             METH_NOARGS,
3033      PyDoc_STR("-> (cls, state)")},
3034 
3035     {NULL, NULL}
3036 };
3037 
3038 static char tzinfo_doc[] =
3039 PyDoc_STR("Abstract base class for time zone info objects.");
3040 
3041 statichere PyTypeObject PyDateTime_TZInfoType = {
3042     PyObject_HEAD_INIT(NULL)
3043     0,                                          /* ob_size */
3044     "datetime.tzinfo",                          /* tp_name */
3045     sizeof(PyDateTime_TZInfo),                  /* tp_basicsize */
3046     0,                                          /* tp_itemsize */
3047     0,                                          /* tp_dealloc */
3048     0,                                          /* tp_print */
3049     0,                                          /* tp_getattr */
3050     0,                                          /* tp_setattr */
3051     0,                                          /* tp_compare */
3052     0,                                          /* tp_repr */
3053     0,                                          /* tp_as_number */
3054     0,                                          /* tp_as_sequence */
3055     0,                                          /* tp_as_mapping */
3056     0,                                          /* tp_hash */
3057     0,                                          /* tp_call */
3058     0,                                          /* tp_str */
3059     PyObject_GenericGetAttr,                    /* tp_getattro */
3060     0,                                          /* tp_setattro */
3061     0,                                          /* tp_as_buffer */
3062     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
3063     Py_TPFLAGS_BASETYPE,                        /* tp_flags */
3064     tzinfo_doc,                                 /* tp_doc */
3065     0,                                          /* tp_traverse */
3066     0,                                          /* tp_clear */
3067     0,                                          /* tp_richcompare */
3068     0,                                          /* tp_weaklistoffset */
3069     0,                                          /* tp_iter */
3070     0,                                          /* tp_iternext */
3071     tzinfo_methods,                             /* tp_methods */
3072     0,                                          /* tp_members */
3073     0,                                          /* tp_getset */
3074     0,                                          /* tp_base */
3075     0,                                          /* tp_dict */
3076     0,                                          /* tp_descr_get */
3077     0,                                          /* tp_descr_set */
3078     0,                                          /* tp_dictoffset */
3079     0,                                          /* tp_init */
3080     0,                                          /* tp_alloc */
3081     PyType_GenericNew,                          /* tp_new */
3082     0,                                          /* tp_free */
3083 };
3084 
3085 /*
3086  * PyDateTime_Time implementation.
3087  */
3088 
3089 /* Accessor properties.
3090  */
3091 
3092 static PyObject *
3093 time_hour(PyDateTime_Time *self, void *unused)
3094 {
3095     return PyInt_FromLong(TIME_GET_HOUR(self));
3096 }
3097 
3098 static PyObject *
3099 time_minute(PyDateTime_Time *self, void *unused)
3100 {
3101     return PyInt_FromLong(TIME_GET_MINUTE(self));
3102 }
3103 
3104 /* The name time_second conflicted with some platform header file. */
3105 static PyObject *
3106 py_time_second(PyDateTime_Time *self, void *unused)
3107 {
3108     return PyInt_FromLong(TIME_GET_SECOND(self));
3109 }
3110 
3111 static PyObject *
3112 time_microsecond(PyDateTime_Time *self, void *unused)
3113 {
3114     return PyInt_FromLong(TIME_GET_MICROSECOND(self));
3115 }
3116 
3117 static PyObject *
3118 time_tzinfo(PyDateTime_Time *self, void *unused)
3119 {
3120     PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None;
3121     Py_INCREF(result);
3122     return result;
3123 }
3124 
3125 static PyGetSetDef time_getset[] = {
3126     {"hour",        (getter)time_hour},
3127     {"minute",      (getter)time_minute},
3128     {"second",      (getter)py_time_second},
3129     {"microsecond", (getter)time_microsecond},
3130     {"tzinfo",          (getter)time_tzinfo},
3131     {NULL}
3132 };
3133 
3134 /*
3135  * Constructors.
3136  */
3137 
3138 static char *time_kws[] = {"hour", "minute", "second", "microsecond",
3139                            "tzinfo", NULL};
3140 
3141 static PyObject *
3142 time_new(PyTypeObject *type, PyObject *args, PyObject *kw)
3143 {
3144     PyObject *self = NULL;
3145     PyObject *state;
3146     int hour = 0;
3147     int minute = 0;
3148     int second = 0;
3149     int usecond = 0;
3150     PyObject *tzinfo = Py_None;
3151 
3152     /* Check for invocation from pickle with __getstate__ state */
3153     if (PyTuple_GET_SIZE(args) >= 1 &&
3154         PyTuple_GET_SIZE(args) <= 2 &&
3155         PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
3156         PyString_GET_SIZE(state) == _PyDateTime_TIME_DATASIZE &&
3157         ((unsigned char) (PyString_AS_STRING(state)[0])) < 24)
3158     {
3159         PyDateTime_Time *me;
3160         char aware;
3161 
3162         if (PyTuple_GET_SIZE(args) == 2) {
3163             tzinfo = PyTuple_GET_ITEM(args, 1);
3164             if (check_tzinfo_subclass(tzinfo) < 0) {
3165                 PyErr_SetString(PyExc_TypeError, "bad "
3166                     "tzinfo state arg");
3167                 return NULL;
3168             }
3169         }
3170         aware = (char)(tzinfo != Py_None);
3171         me = (PyDateTime_Time *) (type->tp_alloc(type, aware));
3172         if (me != NULL) {
3173             char *pdata = PyString_AS_STRING(state);
3174 
3175             memcpy(me->data, pdata, _PyDateTime_TIME_DATASIZE);
3176             me->hashcode = -1;
3177             me->hastzinfo = aware;
3178             if (aware) {
3179                 Py_INCREF(tzinfo);
3180                 me->tzinfo = tzinfo;
3181             }
3182         }
3183         return (PyObject *)me;
3184     }
3185 
3186     if (PyArg_ParseTupleAndKeywords(args, kw, "|iiiiO", time_kws,
3187                                     &hour, &minute, &second, &usecond,
3188                                     &tzinfo)) {
3189         if (check_time_args(hour, minute, second, usecond) < 0)
3190             return NULL;
3191         if (check_tzinfo_subclass(tzinfo) < 0)
3192             return NULL;
3193         self = new_time_ex(hour, minute, second, usecond, tzinfo,
3194                            type);
3195     }
3196     return self;
3197 }
3198 
3199 /*
3200  * Destructor.
3201  */
3202 
3203 static void
3204 time_dealloc(PyDateTime_Time *self)
3205 {
3206     if (HASTZINFO(self)) {
3207         Py_XDECREF(self->tzinfo);
3208     }
3209     Py_TYPE(self)->tp_free((PyObject *)self);
3210 }
3211 
3212 /*
3213  * Indirect access to tzinfo methods.
3214  */
3215 
3216 /* These are all METH_NOARGS, so don't need to check the arglist. */
3217 static PyObject *
3218 time_utcoffset(PyDateTime_Time *self, PyObject *unused) {
3219     return offset_as_timedelta(HASTZINFO(self) ? self->tzinfo : Py_None,
3220                                "utcoffset", Py_None);
3221 }
3222 
3223 static PyObject *
3224 time_dst(PyDateTime_Time *self, PyObject *unused) {
3225     return offset_as_timedelta(HASTZINFO(self) ? self->tzinfo : Py_None,
3226                                "dst", Py_None);
3227 }
3228 
3229 static PyObject *
3230 time_tzname(PyDateTime_Time *self, PyObject *unused) {
3231     return call_tzname(HASTZINFO(self) ? self->tzinfo : Py_None,
3232                        Py_None);
3233 }
3234 
3235 /*
3236  * Various ways to turn a time into a string.
3237  */
3238 
3239 static PyObject *
3240 time_repr(PyDateTime_Time *self)
3241 {
3242     char buffer[100];
3243     const char *type_name = Py_TYPE(self)->tp_name;
3244     int h = TIME_GET_HOUR(self);
3245     int m = TIME_GET_MINUTE(self);
3246     int s = TIME_GET_SECOND(self);
3247     int us = TIME_GET_MICROSECOND(self);
3248     PyObject *result = NULL;
3249 
3250     if (us)
3251         PyOS_snprintf(buffer, sizeof(buffer),
3252                       "%s(%d, %d, %d, %d)", type_name, h, m, s, us);
3253     else if (s)
3254         PyOS_snprintf(buffer, sizeof(buffer),
3255                       "%s(%d, %d, %d)", type_name, h, m, s);
3256     else
3257         PyOS_snprintf(buffer, sizeof(buffer),
3258                       "%s(%d, %d)", type_name, h, m);
3259     result = PyString_FromString(buffer);
3260     if (result != NULL && HASTZINFO(self))
3261         result = append_keyword_tzinfo(result, self->tzinfo);
3262     return result;
3263 }
3264 
3265 static PyObject *
3266 time_str(PyDateTime_Time *self)
3267 {
3268     return PyObject_CallMethod((PyObject *)self, "isoformat", "()");
3269 }
3270 
3271 static PyObject *
3272 time_isoformat(PyDateTime_Time *self, PyObject *unused)
3273 {
3274     char buf[100];
3275     PyObject *result;
3276     /* Reuse the time format code from the datetime type. */
3277     PyDateTime_DateTime datetime;
3278     PyDateTime_DateTime *pdatetime = &datetime;
3279 
3280     /* Copy over just the time bytes. */
3281     memcpy(pdatetime->data + _PyDateTime_DATE_DATASIZE,
3282            self->data,
3283            _PyDateTime_TIME_DATASIZE);
3284 
3285     isoformat_time(pdatetime, buf, sizeof(buf));
3286     result = PyString_FromString(buf);
3287     if (result == NULL || ! HASTZINFO(self) || self->tzinfo == Py_None)
3288         return result;
3289 
3290     /* We need to append the UTC offset. */
3291     if (format_utcoffset(buf, sizeof(buf), ":", self->tzinfo,
3292                          Py_None) < 0) {
3293         Py_DECREF(result);
3294         return NULL;
3295     }
3296     PyString_ConcatAndDel(&result, PyString_FromString(buf));
3297     return result;
3298 }
3299 
3300 static PyObject *
3301 time_strftime(PyDateTime_Time *self, PyObject *args, PyObject *kw)
3302 {
3303     PyObject *result;
3304     PyObject *tuple;
3305     const char *format;
3306     Py_ssize_t format_len;
3307     static char *keywords[] = {"format", NULL};
3308 
3309     if (! PyArg_ParseTupleAndKeywords(args, kw, "s#:strftime", keywords,
3310                                       &format, &format_len))
3311         return NULL;
3312 
3313     /* Python's strftime does insane things with the year part of the
3314      * timetuple.  The year is forced to (the otherwise nonsensical)
3315      * 1900 to worm around that.
3316      */
3317     tuple = Py_BuildValue("iiiiiiiii",
3318                           1900, 1, 1, /* year, month, day */
3319                   TIME_GET_HOUR(self),
3320                   TIME_GET_MINUTE(self),
3321                   TIME_GET_SECOND(self),
3322                   0, 1, -1); /* weekday, daynum, dst */
3323     if (tuple == NULL)
3324         return NULL;
3325     assert(PyTuple_Size(tuple) == 9);
3326     result = wrap_strftime((PyObject *)self, format, format_len, tuple,
3327                            Py_None);
3328     Py_DECREF(tuple);
3329     return result;
3330 }
3331 
3332 /*
3333  * Miscellaneous methods.
3334  */
3335 
3336 /* This is more natural as a tp_compare, but doesn't work then:  for whatever
3337  * reason, Python's try_3way_compare ignores tp_compare unless
3338  * PyInstance_Check returns true, but these aren't old-style classes.
3339  */
3340 static PyObject *
3341 time_richcompare(PyDateTime_Time *self, PyObject *other, int op)
3342 {
3343     int diff;
3344     naivety n1, n2;
3345     int offset1, offset2;
3346 
3347     if (! PyTime_Check(other)) {
3348         if (op == Py_EQ || op == Py_NE) {
3349             PyObject *result = op == Py_EQ ? Py_False : Py_True;
3350             Py_INCREF(result);
3351             return result;
3352         }
3353         /* Stop this from falling back to address comparison. */
3354         return cmperror((PyObject *)self, other);
3355     }
3356     if (classify_two_utcoffsets((PyObject *)self, &offset1, &n1, Py_None,
3357                                  other, &offset2, &n2, Py_None) < 0)
3358         return NULL;
3359     assert(n1 != OFFSET_UNKNOWN && n2 != OFFSET_UNKNOWN);
3360     /* If they're both naive, or both aware and have the same offsets,
3361      * we get off cheap.  Note that if they're both naive, offset1 ==
3362      * offset2 == 0 at this point.
3363      */
3364     if (n1 == n2 && offset1 == offset2) {
3365         diff = memcmp(self->data, ((PyDateTime_Time *)other)->data,
3366                       _PyDateTime_TIME_DATASIZE);
3367         return diff_to_bool(diff, op);
3368     }
3369 
3370     if (n1 == OFFSET_AWARE && n2 == OFFSET_AWARE) {
3371         assert(offset1 != offset2);             /* else last "if" handled it */
3372         /* Convert everything except microseconds to seconds.  These
3373          * can't overflow (no more than the # of seconds in 2 days).
3374          */
3375         offset1 = TIME_GET_HOUR(self) * 3600 +
3376                   (TIME_GET_MINUTE(self) - offset1) * 60 +
3377                   TIME_GET_SECOND(self);
3378         offset2 = TIME_GET_HOUR(other) * 3600 +
3379                   (TIME_GET_MINUTE(other) - offset2) * 60 +
3380                   TIME_GET_SECOND(other);
3381         diff = offset1 - offset2;
3382         if (diff == 0)
3383             diff = TIME_GET_MICROSECOND(self) -
3384                    TIME_GET_MICROSECOND(other);
3385         return diff_to_bool(diff, op);
3386     }
3387 
3388     assert(n1 != n2);
3389     PyErr_SetString(PyExc_TypeError,
3390                     "can't compare offset-naive and "
3391                     "offset-aware times");
3392     return NULL;
3393 }
3394 
3395 static long
3396 time_hash(PyDateTime_Time *self)
3397 {
3398     if (self->hashcode == -1) {
3399         naivety n;
3400         int offset;
3401         PyObject *temp;
3402 
3403         n = classify_utcoffset((PyObject *)self, Py_None, &offset);
3404         assert(n != OFFSET_UNKNOWN);
3405         if (n == OFFSET_ERROR)
3406             return -1;
3407 
3408         /* Reduce this to a hash of another object. */
3409         if (offset == 0)
3410             temp = PyString_FromStringAndSize((char *)self->data,
3411                                     _PyDateTime_TIME_DATASIZE);
3412         else {
3413             int hour;
3414             int minute;
3415 
3416             assert(n == OFFSET_AWARE);
3417             assert(HASTZINFO(self));
3418             hour = divmod(TIME_GET_HOUR(self) * 60 +
3419                             TIME_GET_MINUTE(self) - offset,
3420                           60,
3421                           &minute);
3422             if (0 <= hour && hour < 24)
3423                 temp = new_time(hour, minute,
3424                                 TIME_GET_SECOND(self),
3425                                 TIME_GET_MICROSECOND(self),
3426                                 Py_None);
3427             else
3428                 temp = Py_BuildValue("iiii",
3429                            hour, minute,
3430                            TIME_GET_SECOND(self),
3431                            TIME_GET_MICROSECOND(self));
3432         }
3433         if (temp != NULL) {
3434             self->hashcode = PyObject_Hash(temp);
3435             Py_DECREF(temp);
3436         }
3437     }
3438     return self->hashcode;
3439 }
3440 
3441 static PyObject *
3442 time_replace(PyDateTime_Time *self, PyObject *args, PyObject *kw)
3443 {
3444     PyObject *clone;
3445     PyObject *tuple;
3446     int hh = TIME_GET_HOUR(self);
3447     int mm = TIME_GET_MINUTE(self);
3448     int ss = TIME_GET_SECOND(self);
3449     int us = TIME_GET_MICROSECOND(self);
3450     PyObject *tzinfo = HASTZINFO(self) ? self->tzinfo : Py_None;
3451 
3452     if (! PyArg_ParseTupleAndKeywords(args, kw, "|iiiiO:replace",
3453                                       time_kws,
3454                                       &hh, &mm, &ss, &us, &tzinfo))
3455         return NULL;
3456     tuple = Py_BuildValue("iiiiO", hh, mm, ss, us, tzinfo);
3457     if (tuple == NULL)
3458         return NULL;
3459     clone = time_new(Py_TYPE(self), tuple, NULL);
3460     Py_DECREF(tuple);
3461     return clone;
3462 }
3463 
3464 static int
3465 time_nonzero(PyDateTime_Time *self)
3466 {
3467     int offset;
3468     int none;
3469 
3470     if (TIME_GET_SECOND(self) || TIME_GET_MICROSECOND(self)) {
3471         /* Since utcoffset is in whole minutes, nothing can
3472          * alter the conclusion that this is nonzero.
3473          */
3474         return 1;
3475     }
3476     offset = 0;
3477     if (HASTZINFO(self) && self->tzinfo != Py_None) {
3478         offset = call_utcoffset(self->tzinfo, Py_None, &none);
3479         if (offset == -1 && PyErr_Occurred())
3480             return -1;
3481     }
3482     return (TIME_GET_MINUTE(self) - offset + TIME_GET_HOUR(self)*60) != 0;
3483 }
3484 
3485 /* Pickle support, a simple use of __reduce__. */
3486 
3487 /* Let basestate be the non-tzinfo data string.
3488  * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo).
3489  * So it's a tuple in any (non-error) case.
3490  * __getstate__ isn't exposed.
3491  */
3492 static PyObject *
3493 time_getstate(PyDateTime_Time *self)
3494 {
3495     PyObject *basestate;
3496     PyObject *result = NULL;
3497 
3498     basestate =  PyString_FromStringAndSize((char *)self->data,
3499                                             _PyDateTime_TIME_DATASIZE);
3500     if (basestate != NULL) {
3501         if (! HASTZINFO(self) || self->tzinfo == Py_None)
3502             result = PyTuple_Pack(1, basestate);
3503         else
3504             result = PyTuple_Pack(2, basestate, self->tzinfo);
3505         Py_DECREF(basestate);
3506     }
3507     return result;
3508 }
3509 
3510 static PyObject *
3511 time_reduce(PyDateTime_Time *self, PyObject *arg)
3512 {
3513     return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self));
3514 }
3515 
3516 static PyMethodDef time_methods[] = {
3517 
3518     {"isoformat",   (PyCFunction)time_isoformat,        METH_NOARGS,
3519      PyDoc_STR("Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]"
3520                "[+HH:MM].")},
3521 
3522     {"strftime",        (PyCFunction)time_strftime,     METH_VARARGS | METH_KEYWORDS,
3523      PyDoc_STR("format -> strftime() style string.")},
3524 
3525     {"__format__",      (PyCFunction)date_format,       METH_VARARGS,
3526      PyDoc_STR("Formats self with strftime.")},
3527 
3528     {"utcoffset",       (PyCFunction)time_utcoffset,    METH_NOARGS,
3529      PyDoc_STR("Return self.tzinfo.utcoffset(self).")},
3530 
3531     {"tzname",          (PyCFunction)time_tzname,       METH_NOARGS,
3532      PyDoc_STR("Return self.tzinfo.tzname(self).")},
3533 
3534     {"dst",             (PyCFunction)time_dst,          METH_NOARGS,
3535      PyDoc_STR("Return self.tzinfo.dst(self).")},
3536 
3537     {"replace",     (PyCFunction)time_replace,          METH_VARARGS | METH_KEYWORDS,
3538      PyDoc_STR("Return time with new specified fields.")},
3539 
3540     {"__reduce__", (PyCFunction)time_reduce,        METH_NOARGS,
3541      PyDoc_STR("__reduce__() -> (cls, state)")},
3542 
3543     {NULL,      NULL}
3544 };
3545 
3546 static char time_doc[] =
3547 PyDoc_STR("time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\
3548 \n\
3549 All arguments are optional. tzinfo may be None, or an instance of\n\
3550 a tzinfo subclass. The remaining arguments may be ints or longs.\n");
3551 
3552 static PyNumberMethods time_as_number = {
3553     0,                                          /* nb_add */
3554     0,                                          /* nb_subtract */
3555     0,                                          /* nb_multiply */
3556     0,                                          /* nb_divide */
3557     0,                                          /* nb_remainder */
3558     0,                                          /* nb_divmod */
3559     0,                                          /* nb_power */
3560     0,                                          /* nb_negative */
3561     0,                                          /* nb_positive */
3562     0,                                          /* nb_absolute */
3563     (inquiry)time_nonzero,                      /* nb_nonzero */
3564 };
3565 
3566 statichere PyTypeObject PyDateTime_TimeType = {
3567     PyObject_HEAD_INIT(NULL)
3568     0,                                          /* ob_size */
3569     "datetime.time",                            /* tp_name */
3570     sizeof(PyDateTime_Time),                    /* tp_basicsize */
3571     0,                                          /* tp_itemsize */
3572     (destructor)time_dealloc,                   /* tp_dealloc */
3573     0,                                          /* tp_print */
3574     0,                                          /* tp_getattr */
3575     0,                                          /* tp_setattr */
3576     0,                                          /* tp_compare */
3577     (reprfunc)time_repr,                        /* tp_repr */
3578     &time_as_number,                            /* tp_as_number */
3579     0,                                          /* tp_as_sequence */
3580     0,                                          /* tp_as_mapping */
3581     (hashfunc)time_hash,                        /* tp_hash */
3582     0,                                          /* tp_call */
3583     (reprfunc)time_str,                         /* tp_str */
3584     PyObject_GenericGetAttr,                    /* tp_getattro */
3585     0,                                          /* tp_setattro */
3586     0,                                          /* tp_as_buffer */
3587     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
3588     Py_TPFLAGS_BASETYPE,                        /* tp_flags */
3589     time_doc,                                   /* tp_doc */
3590     0,                                          /* tp_traverse */
3591     0,                                          /* tp_clear */
3592     (richcmpfunc)time_richcompare,              /* tp_richcompare */
3593     0,                                          /* tp_weaklistoffset */
3594     0,                                          /* tp_iter */
3595     0,                                          /* tp_iternext */
3596     time_methods,                               /* tp_methods */
3597     0,                                          /* tp_members */
3598     time_getset,                                /* tp_getset */
3599     0,                                          /* tp_base */
3600     0,                                          /* tp_dict */
3601     0,                                          /* tp_descr_get */
3602     0,                                          /* tp_descr_set */
3603     0,                                          /* tp_dictoffset */
3604     0,                                          /* tp_init */
3605     time_alloc,                                 /* tp_alloc */
3606     time_new,                                   /* tp_new */
3607     0,                                          /* tp_free */
3608 };
3609 
3610 /*
3611  * PyDateTime_DateTime implementation.
3612  */
3613 
3614 /* Accessor properties.  Properties for day, month, and year are inherited
3615  * from date.
3616  */
3617 
3618 static PyObject *
3619 datetime_hour(PyDateTime_DateTime *self, void *unused)
3620 {
3621     return PyInt_FromLong(DATE_GET_HOUR(self));
3622 }
3623 
3624 static PyObject *
3625 datetime_minute(PyDateTime_DateTime *self, void *unused)
3626 {
3627     return PyInt_FromLong(DATE_GET_MINUTE(self));
3628 }
3629 
3630 static PyObject *
3631 datetime_second(PyDateTime_DateTime *self, void *unused)
3632 {
3633     return PyInt_FromLong(DATE_GET_SECOND(self));
3634 }
3635 
3636 static PyObject *
3637 datetime_microsecond(PyDateTime_DateTime *self, void *unused)
3638 {
3639     return PyInt_FromLong(DATE_GET_MICROSECOND(self));
3640 }
3641 
3642 static PyObject *
3643 datetime_tzinfo(PyDateTime_DateTime *self, void *unused)
3644 {
3645     PyObject *result = HASTZINFO(self) ? self->tzinfo : Py_None;
3646     Py_INCREF(result);
3647     return result;
3648 }
3649 
3650 static PyGetSetDef datetime_getset[] = {
3651     {"hour",        (getter)datetime_hour},
3652     {"minute",      (getter)datetime_minute},
3653     {"second",      (getter)datetime_second},
3654     {"microsecond", (getter)datetime_microsecond},
3655     {"tzinfo",          (getter)datetime_tzinfo},
3656     {NULL}
3657 };
3658 
3659 /*
3660  * Constructors.
3661  */
3662 
3663 static char *datetime_kws[] = {
3664     "year", "month", "day", "hour", "minute", "second",
3665     "microsecond", "tzinfo", NULL
3666 };
3667 
3668 static PyObject *
3669 datetime_new(PyTypeObject *type, PyObject *args, PyObject *kw)
3670 {
3671     PyObject *self = NULL;
3672     PyObject *state;
3673     int year;
3674     int month;
3675     int day;
3676     int hour = 0;
3677     int minute = 0;
3678     int second = 0;
3679     int usecond = 0;
3680     PyObject *tzinfo = Py_None;
3681 
3682     /* Check for invocation from pickle with __getstate__ state */
3683     if (PyTuple_GET_SIZE(args) >= 1 &&
3684         PyTuple_GET_SIZE(args) <= 2 &&
3685         PyString_Check(state = PyTuple_GET_ITEM(args, 0)) &&
3686         PyString_GET_SIZE(state) == _PyDateTime_DATETIME_DATASIZE &&
3687         MONTH_IS_SANE(PyString_AS_STRING(state)[2]))
3688     {
3689         PyDateTime_DateTime *me;
3690         char aware;
3691 
3692         if (PyTuple_GET_SIZE(args) == 2) {
3693             tzinfo = PyTuple_GET_ITEM(args, 1);
3694             if (check_tzinfo_subclass(tzinfo) < 0) {
3695                 PyErr_SetString(PyExc_TypeError, "bad "
3696                     "tzinfo state arg");
3697                 return NULL;
3698             }
3699         }
3700         aware = (char)(tzinfo != Py_None);
3701         me = (PyDateTime_DateTime *) (type->tp_alloc(type , aware));
3702         if (me != NULL) {
3703             char *pdata = PyString_AS_STRING(state);
3704 
3705             memcpy(me->data, pdata, _PyDateTime_DATETIME_DATASIZE);
3706             me->hashcode = -1;
3707             me->hastzinfo = aware;
3708             if (aware) {
3709                 Py_INCREF(tzinfo);
3710                 me->tzinfo = tzinfo;
3711             }
3712         }
3713         return (PyObject *)me;
3714     }
3715 
3716     if (PyArg_ParseTupleAndKeywords(args, kw, "iii|iiiiO", datetime_kws,
3717                                     &year, &month, &day, &hour, &minute,
3718                                     &second, &usecond, &tzinfo)) {
3719         if (check_date_args(year, month, day) < 0)
3720             return NULL;
3721         if (check_time_args(hour, minute, second, usecond) < 0)
3722             return NULL;
3723         if (check_tzinfo_subclass(tzinfo) < 0)
3724             return NULL;
3725         self = new_datetime_ex(year, month, day,
3726                                 hour, minute, second, usecond,
3727                                 tzinfo, type);
3728     }
3729     return self;
3730 }
3731 
3732 /* TM_FUNC is the shared type of localtime() and gmtime(). */
3733 typedef struct tm *(*TM_FUNC)(const time_t *timer);
3734 
3735 /* Internal helper.
3736  * Build datetime from a time_t and a distinct count of microseconds.
3737  * Pass localtime or gmtime for f, to control the interpretation of timet.
3738  */
3739 static PyObject *
3740 datetime_from_timet_and_us(PyObject *cls, TM_FUNC f, time_t timet, int us,
3741                            PyObject *tzinfo)
3742 {
3743     struct tm *tm;
3744     PyObject *result = NULL;
3745 
3746     tm = f(&timet);
3747     if (tm) {
3748         /* The platform localtime/gmtime may insert leap seconds,
3749          * indicated by tm->tm_sec > 59.  We don't care about them,
3750          * except to the extent that passing them on to the datetime
3751          * constructor would raise ValueError for a reason that
3752          * made no sense to the user.
3753          */
3754         if (tm->tm_sec > 59)
3755             tm->tm_sec = 59;
3756         result = PyObject_CallFunction(cls, "iiiiiiiO",
3757                                        tm->tm_year + 1900,
3758                                        tm->tm_mon + 1,
3759                                        tm->tm_mday,
3760                                        tm->tm_hour,
3761                                        tm->tm_min,
3762                                        tm->tm_sec,
3763                                        us,
3764                                        tzinfo);
3765     }
3766     else
3767         PyErr_SetString(PyExc_ValueError,
3768                         "timestamp out of range for "
3769                         "platform localtime()/gmtime() function");
3770     return result;
3771 }
3772 
3773 /* Internal helper.
3774  * Build datetime from a Python timestamp.  Pass localtime or gmtime for f,
3775  * to control the interpretation of the timestamp.  Since a double doesn't
3776  * have enough bits to cover a datetime's full range of precision, it's
3777  * better to call datetime_from_timet_and_us provided you have a way
3778  * to get that much precision (e.g., C time() isn't good enough).
3779  */
3780 static PyObject *
3781 datetime_from_timestamp(PyObject *cls, TM_FUNC f, double timestamp,
3782                         PyObject *tzinfo)
3783 {
3784     time_t timet;
3785     double fraction;
3786     int us;
3787 
3788     timet = _PyTime_DoubleToTimet(timestamp);
3789     if (timet == (time_t)-1 && PyErr_Occurred())
3790         return NULL;
3791     fraction = timestamp - (double)timet;
3792     us = (int)round_to_long(fraction * 1e6);
3793     if (us < 0) {
3794         /* Truncation towards zero is not what we wanted
3795            for negative numbers (Python's mod semantics) */
3796         timet -= 1;
3797         us += 1000000;
3798     }
3799     /* If timestamp is less than one microsecond smaller than a
3800      * full second, round up. Otherwise, ValueErrors are raised
3801      * for some floats. */
3802     if (us == 1000000) {
3803         timet += 1;
3804         us = 0;
3805     }
3806     return datetime_from_timet_and_us(cls, f, timet, us, tzinfo);
3807 }
3808 
3809 /* Internal helper.
3810  * Build most accurate possible datetime for current time.  Pass localtime or
3811  * gmtime for f as appropriate.
3812  */
3813 static PyObject *
3814 datetime_best_possible(PyObject *cls, TM_FUNC f, PyObject *tzinfo)
3815 {
3816 #ifdef HAVE_GETTIMEOFDAY
3817     struct timeval t;
3818 
3819 #ifdef GETTIMEOFDAY_NO_TZ
3820     gettimeofday(&t);
3821 #else
3822     gettimeofday(&t, (struct timezone *)NULL);
3823 #endif
3824     return datetime_from_timet_and_us(cls, f, t.tv_sec, (int)t.tv_usec,
3825                                       tzinfo);
3826 
3827 #else   /* ! HAVE_GETTIMEOFDAY */
3828     /* No flavor of gettimeofday exists on this platform.  Python's
3829      * time.time() does a lot of other platform tricks to get the
3830      * best time it can on the platform, and we're not going to do
3831      * better than that (if we could, the better code would belong
3832      * in time.time()!)  We're limited by the precision of a double,
3833      * though.
3834      */
3835     PyObject *time;
3836     double dtime;
3837 
3838     time = time_time();
3839     if (time == NULL)
3840         return NULL;
3841     dtime = PyFloat_AsDouble(time);
3842     Py_DECREF(time);
3843     if (dtime == -1.0 && PyErr_Occurred())
3844         return NULL;
3845     return datetime_from_timestamp(cls, f, dtime, tzinfo);
3846 #endif  /* ! HAVE_GETTIMEOFDAY */
3847 }
3848 
3849 /* Return best possible local time -- this isn't constrained by the
3850  * precision of a timestamp.
3851  */
3852 static PyObject *
3853 datetime_now(PyObject *cls, PyObject *args, PyObject *kw)
3854 {
3855     PyObject *self;
3856     PyObject *tzinfo = Py_None;
3857     static char *keywords[] = {"tz", NULL};
3858 
3859     if (! PyArg_ParseTupleAndKeywords(args, kw, "|O:now", keywords,
3860                                       &tzinfo))
3861         return NULL;
3862     if (check_tzinfo_subclass(tzinfo) < 0)
3863         return NULL;
3864 
3865     self = datetime_best_possible(cls,
3866                                   tzinfo == Py_None ? localtime : gmtime,
3867                                   tzinfo);
3868     if (self != NULL && tzinfo != Py_None) {
3869         /* Convert UTC to tzinfo's zone. */
3870         PyObject *temp = self;
3871         self = PyObject_CallMethod(tzinfo, "fromutc", "O", self);
3872         Py_DECREF(temp);
3873     }
3874     return self;
3875 }
3876 
3877 /* Return best possible UTC time -- this isn't constrained by the
3878  * precision of a timestamp.
3879  */
3880 static PyObject *
3881 datetime_utcnow(PyObject *cls, PyObject *dummy)
3882 {
3883     return datetime_best_possible(cls, gmtime, Py_None);
3884 }
3885 
3886 /* Return new local datetime from timestamp (Python timestamp -- a double). */
3887 static PyObject *
3888 datetime_fromtimestamp(PyObject *cls, PyObject *args, PyObject *kw)
3889 {
3890     PyObject *self;
3891     double timestamp;
3892     PyObject *tzinfo = Py_None;
3893     static char *keywords[] = {"timestamp", "tz", NULL};
3894 
3895     if (! PyArg_ParseTupleAndKeywords(args, kw, "d|O:fromtimestamp",
3896                                       keywords, &timestamp, &tzinfo))
3897         return NULL;
3898     if (check_tzinfo_subclass(tzinfo) < 0)
3899         return NULL;
3900 
3901     self = datetime_from_timestamp(cls,
3902                                    tzinfo == Py_None ? localtime : gmtime,
3903                                    timestamp,
3904                                    tzinfo);
3905     if (self != NULL && tzinfo != Py_None) {
3906         /* Convert UTC to tzinfo's zone. */
3907         PyObject *temp = self;
3908         self = PyObject_CallMethod(tzinfo, "fromutc", "O", self);
3909         Py_DECREF(temp);
3910     }
3911     return self;
3912 }
3913 
3914 /* Return new UTC datetime from timestamp (Python timestamp -- a double). */
3915 static PyObject *
3916 datetime_utcfromtimestamp(PyObject *cls, PyObject *args)
3917 {
3918     double timestamp;
3919     PyObject *result = NULL;
3920 
3921     if (PyArg_ParseTuple(args, "d:utcfromtimestamp", &timestamp))
3922         result = datetime_from_timestamp(cls, gmtime, timestamp,
3923                                          Py_None);
3924     return result;
3925 }
3926 
3927 /* Return new datetime from time.strptime(). */
3928 static PyObject *
3929 datetime_strptime(PyObject *cls, PyObject *args)
3930 {
3931     static PyObject *module = NULL;
3932     PyObject *result = NULL, *obj, *st = NULL, *frac = NULL;
3933     const char *string, *format;
3934 
3935     if (!PyArg_ParseTuple(args, "ss:strptime", &string, &format))
3936         return NULL;
3937 
3938     if (module == NULL &&
3939         (module = PyImport_ImportModuleNoBlock("_strptime")) == NULL)
3940         return NULL;
3941 
3942     /* _strptime._strptime returns a two-element tuple.  The first
3943        element is a time.struct_time object.  The second is the
3944        microseconds (which are not defined for time.struct_time). */
3945     obj = PyObject_CallMethod(module, "_strptime", "ss", string, format);
3946     if (obj != NULL) {
3947         int i, good_timetuple = 1;
3948         long int ia[7];
3949         if (PySequence_Check(obj) && PySequence_Size(obj) == 2) {
3950             st = PySequence_GetItem(obj, 0);
3951             frac = PySequence_GetItem(obj, 1);
3952             if (st == NULL || frac == NULL)
3953                 good_timetuple = 0;
3954             /* copy y/m/d/h/m/s values out of the
3955                time.struct_time */
3956             if (good_timetuple &&
3957                 PySequence_Check(st) &&
3958                 PySequence_Size(st) >= 6) {
3959                 for (i=0; i < 6; i++) {
3960                     PyObject *p = PySequence_GetItem(st, i);
3961                     if (p == NULL) {
3962                         good_timetuple = 0;
3963                         break;
3964                     }
3965                     if (PyInt_Check(p))
3966                         ia[i] = PyInt_AsLong(p);
3967                     else
3968                         good_timetuple = 0;
3969                     Py_DECREF(p);
3970                 }
3971             }
3972             else
3973                 good_timetuple = 0;
3974             /* follow that up with a little dose of microseconds */
3975             if (good_timetuple && PyInt_Check(frac))
3976                 ia[6] = PyInt_AsLong(frac);
3977             else
3978                 good_timetuple = 0;
3979         }
3980         else
3981             good_timetuple = 0;
3982         if (good_timetuple)
3983             result = PyObject_CallFunction(cls, "iiiiiii",
3984                                            ia[0], ia[1], ia[2],
3985                                            ia[3], ia[4], ia[5],
3986                                            ia[6]);
3987         else
3988             PyErr_SetString(PyExc_ValueError,
3989                 "unexpected value from _strptime._strptime");
3990     }
3991     Py_XDECREF(obj);
3992     Py_XDECREF(st);
3993     Py_XDECREF(frac);
3994     return result;
3995 }
3996 
3997 /* Return new datetime from date/datetime and time arguments. */
3998 static PyObject *
3999 datetime_combine(PyObject *cls, PyObject *args, PyObject *kw)
4000 {
4001     static char *keywords[] = {"date", "time", NULL};
4002     PyObject *date;
4003     PyObject *time;
4004     PyObject *result = NULL;
4005 
4006     if (PyArg_ParseTupleAndKeywords(args, kw, "O!O!:combine", keywords,
4007                                     &PyDateTime_DateType, &date,
4008                                     &PyDateTime_TimeType, &time)) {
4009         PyObject *tzinfo = Py_None;
4010 
4011         if (HASTZINFO(time))
4012             tzinfo = ((PyDateTime_Time *)time)->tzinfo;
4013         result = PyObject_CallFunction(cls, "iiiiiiiO",
4014                                         GET_YEAR(date),
4015                                         GET_MONTH(date),
4016                                         GET_DAY(date),
4017                                         TIME_GET_HOUR(time),
4018                                         TIME_GET_MINUTE(time),
4019                                         TIME_GET_SECOND(time),
4020                                         TIME_GET_MICROSECOND(time),
4021                                         tzinfo);
4022     }
4023     return result;
4024 }
4025 
4026 /*
4027  * Destructor.
4028  */
4029 
4030 static void
4031 datetime_dealloc(PyDateTime_DateTime *self)
4032 {
4033     if (HASTZINFO(self)) {
4034         Py_XDECREF(self->tzinfo);
4035     }
4036     Py_TYPE(self)->tp_free((PyObject *)self);
4037 }
4038 
4039 /*
4040  * Indirect access to tzinfo methods.
4041  */
4042 
4043 /* These are all METH_NOARGS, so don't need to check the arglist. */
4044 static PyObject *
4045 datetime_utcoffset(PyDateTime_DateTime *self, PyObject *unused) {
4046     return offset_as_timedelta(HASTZINFO(self) ? self->tzinfo : Py_None,
4047                                "utcoffset", (PyObject *)self);
4048 }
4049 
4050 static PyObject *
4051 datetime_dst(PyDateTime_DateTime *self, PyObject *unused) {
4052     return offset_as_timedelta(HASTZINFO(self) ? self->tzinfo : Py_None,
4053                                "dst", (PyObject *)self);
4054 }
4055 
4056 static PyObject *
4057 datetime_tzname(PyDateTime_DateTime *self, PyObject *unused) {
4058     return call_tzname(HASTZINFO(self) ? self->tzinfo : Py_None,
4059                        (PyObject *)self);
4060 }
4061 
4062 /*
4063  * datetime arithmetic.
4064  */
4065 
4066 /* factor must be 1 (to add) or -1 (to subtract).  The result inherits
4067  * the tzinfo state of date.
4068  */
4069 static PyObject *
4070 add_datetime_timedelta(PyDateTime_DateTime *date, PyDateTime_Delta *delta,
4071                        int factor)
4072 {
4073     /* Note that the C-level additions can't overflow, because of
4074      * invariant bounds on the member values.
4075      */
4076     int year = GET_YEAR(date);
4077     int month = GET_MONTH(date);
4078     int day = GET_DAY(date) + GET_TD_DAYS(delta) * factor;
4079     int hour = DATE_GET_HOUR(date);
4080     int minute = DATE_GET_MINUTE(date);
4081     int second = DATE_GET_SECOND(date) + GET_TD_SECONDS(delta) * factor;
4082     int microsecond = DATE_GET_MICROSECOND(date) +
4083                       GET_TD_MICROSECONDS(delta) * factor;
4084 
4085     assert(factor == 1 || factor == -1);
4086     if (normalize_datetime(&year, &month, &day,
4087                            &hour, &minute, &second, &microsecond) < 0)
4088         return NULL;
4089     else
4090         return new_datetime(year, month, day,
4091                             hour, minute, second, microsecond,
4092                             HASTZINFO(date) ? date->tzinfo : Py_None);
4093 }
4094 
4095 static PyObject *
4096 datetime_add(PyObject *left, PyObject *right)
4097 {
4098     if (PyDateTime_Check(left)) {
4099         /* datetime + ??? */
4100         if (PyDelta_Check(right))
4101             /* datetime + delta */
4102             return add_datetime_timedelta(
4103                             (PyDateTime_DateTime *)left,
4104                             (PyDateTime_Delta *)right,
4105                             1);
4106     }
4107     else if (PyDelta_Check(left)) {
4108         /* delta + datetime */
4109         return add_datetime_timedelta((PyDateTime_DateTime *) right,
4110                                       (PyDateTime_Delta *) left,
4111                                       1);
4112     }
4113     Py_INCREF(Py_NotImplemented);
4114     return Py_NotImplemented;
4115 }
4116 
4117 static PyObject *
4118 datetime_subtract(PyObject *left, PyObject *right)
4119 {
4120     PyObject *result = Py_NotImplemented;
4121 
4122     if (PyDateTime_Check(left)) {
4123         /* datetime - ??? */
4124         if (PyDateTime_Check(right)) {
4125             /* datetime - datetime */
4126             naivety n1, n2;
4127             int offset1, offset2;
4128             int delta_d, delta_s, delta_us;
4129 
4130             if (classify_two_utcoffsets(left, &offset1, &n1, left,
4131                                         right, &offset2, &n2,
4132                                         right) < 0)
4133                 return NULL;
4134             assert(n1 != OFFSET_UNKNOWN && n2 != OFFSET_UNKNOWN);
4135             if (n1 != n2) {
4136                 PyErr_SetString(PyExc_TypeError,
4137                     "can't subtract offset-naive and "
4138                     "offset-aware datetimes");
4139                 return NULL;
4140             }
4141             delta_d = ymd_to_ord(GET_YEAR(left),
4142                                  GET_MONTH(left),
4143                                  GET_DAY(left)) -
4144                       ymd_to_ord(GET_YEAR(right),
4145                                  GET_MONTH(right),
4146                                  GET_DAY(right));
4147             /* These can't overflow, since the values are
4148              * normalized.  At most this gives the number of
4149              * seconds in one day.
4150              */
4151             delta_s = (DATE_GET_HOUR(left) -
4152                        DATE_GET_HOUR(right)) * 3600 +
4153                       (DATE_GET_MINUTE(left) -
4154                        DATE_GET_MINUTE(right)) * 60 +
4155                       (DATE_GET_SECOND(left) -
4156                        DATE_GET_SECOND(right));
4157             delta_us = DATE_GET_MICROSECOND(left) -
4158                        DATE_GET_MICROSECOND(right);
4159             /* (left - offset1) - (right - offset2) =
4160              * (left - right) + (offset2 - offset1)
4161              */
4162             delta_s += (offset2 - offset1) * 60;
4163             result = new_delta(delta_d, delta_s, delta_us, 1);
4164         }
4165         else if (PyDelta_Check(right)) {
4166             /* datetime - delta */
4167             result = add_datetime_timedelta(
4168                             (PyDateTime_DateTime *)left,
4169                             (PyDateTime_Delta *)right,