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 preceding 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 (void)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 (void)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, µseconds); 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", ×tamp)) 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, ×tamp, &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", ×tamp)) 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, µsecond) < 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, 4170 -1); 4171 } 4172 } 4173 4174 if (result == Py_NotImplemented) 4175 Py_INCREF(result); 4176 return result; 4177 } 4178 4179 /* Various ways to turn a datetime into a string. */ 4180 4181 static PyObject * 4182 datetime_repr(PyDateTime_DateTime *self) 4183 { 4184 char buffer[1000]; 4185 const char *type_name = Py_TYPE(self)->tp_name; 4186 PyObject *baserepr; 4187 4188 if (DATE_GET_MICROSECOND(self)) { 4189 PyOS_snprintf(buffer, sizeof(buffer), 4190 "%s(%d, %d, %d, %d, %d, %d, %d)", 4191 type_name, 4192 GET_YEAR(self), GET_MONTH(self), GET_DAY(self), 4193 DATE_GET_HOUR(self), DATE_GET_MINUTE(self), 4194 DATE_GET_SECOND(self), 4195 DATE_GET_MICROSECOND(self)); 4196 } 4197 else if (DATE_GET_SECOND(self)) { 4198 PyOS_snprintf(buffer, sizeof(buffer), 4199 "%s(%d, %d, %d, %d, %d, %d)", 4200 type_name, 4201 GET_YEAR(self), GET_MONTH(self), GET_DAY(self), 4202 DATE_GET_HOUR(self), DATE_GET_MINUTE(self), 4203 DATE_GET_SECOND(self)); 4204 } 4205 else { 4206 PyOS_snprintf(buffer, sizeof(buffer), 4207 "%s(%d, %d, %d, %d, %d)", 4208 type_name, 4209 GET_YEAR(self), GET_MONTH(self), GET_DAY(self), 4210 DATE_GET_HOUR(self), DATE_GET_MINUTE(self)); 4211 } 4212 baserepr = PyString_FromString(buffer); 4213 if (baserepr == NULL || ! HASTZINFO(self)) 4214 return baserepr; 4215 return append_keyword_tzinfo(baserepr, self->tzinfo); 4216 } 4217 4218 static PyObject * 4219 datetime_str(PyDateTime_DateTime *self) 4220 { 4221 return PyObject_CallMethod((PyObject *)self, "isoformat", "(s)", " "); 4222 } 4223 4224 static PyObject * 4225 datetime_isoformat(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) 4226 { 4227 char sep = 'T'; 4228 static char *keywords[] = {"sep", NULL}; 4229 char buffer[100]; 4230 char *cp; 4231 PyObject *result; 4232 4233 if (!PyArg_ParseTupleAndKeywords(args, kw, "|c:isoformat", keywords, 4234 &sep)) 4235 return NULL; 4236 cp = isoformat_date((PyDateTime_Date *)self, buffer, sizeof(buffer)); 4237 assert(cp != NULL); 4238 *cp++ = sep; 4239 cp = isoformat_time(self, cp, sizeof(buffer) - (cp - buffer)); 4240 result = PyString_FromStringAndSize(buffer, cp - buffer); 4241 if (result == NULL || ! HASTZINFO(self)) 4242 return result; 4243 4244 /* We need to append the UTC offset. */ 4245 if (format_utcoffset(buffer, sizeof(buffer), ":", self->tzinfo, 4246 (PyObject *)self) < 0) { 4247 Py_DECREF(result); 4248 return NULL; 4249 } 4250 PyString_ConcatAndDel(&result, PyString_FromString(buffer)); 4251 return result; 4252 } 4253 4254 static PyObject * 4255 datetime_ctime(PyDateTime_DateTime *self) 4256 { 4257 return format_ctime((PyDateTime_Date *)self, 4258 DATE_GET_HOUR(self), 4259 DATE_GET_MINUTE(self), 4260 DATE_GET_SECOND(self)); 4261 } 4262 4263 /* Miscellaneous methods. */ 4264 4265 /* This is more natural as a tp_compare, but doesn't work then: for whatever 4266 * reason, Python's try_3way_compare ignores tp_compare unless 4267 * PyInstance_Check returns true, but these aren't old-style classes. 4268 */ 4269 static PyObject * 4270 datetime_richcompare(PyDateTime_DateTime *self, PyObject *other, int op) 4271 { 4272 int diff; 4273 naivety n1, n2; 4274 int offset1, offset2; 4275 4276 if (! PyDateTime_Check(other)) { 4277 /* If other has a "timetuple" attr, that's an advertised 4278 * hook for other classes to ask to get comparison control. 4279 * However, date instances have a timetuple attr, and we 4280 * don't want to allow that comparison. Because datetime 4281 * is a subclass of date, when mixing date and datetime 4282 * in a comparison, Python gives datetime the first shot 4283 * (it's the more specific subtype). So we can stop that 4284 * combination here reliably. 4285 */ 4286 if (PyObject_HasAttrString(other, "timetuple") && 4287 ! PyDate_Check(other)) { 4288 /* A hook for other kinds of datetime objects. */ 4289 Py_INCREF(Py_NotImplemented); 4290 return Py_NotImplemented; 4291 } 4292 if (op == Py_EQ || op == Py_NE) { 4293 PyObject *result = op == Py_EQ ? Py_False : Py_True; 4294 Py_INCREF(result); 4295 return result; 4296 } 4297 /* Stop this from falling back to address comparison. */ 4298 return cmperror((PyObject *)self, other); 4299 } 4300 4301 if (classify_two_utcoffsets((PyObject *)self, &offset1, &n1, 4302 (PyObject *)self, 4303 other, &offset2, &n2, 4304 other) < 0) 4305 return NULL; 4306 assert(n1 != OFFSET_UNKNOWN && n2 != OFFSET_UNKNOWN); 4307 /* If they're both naive, or both aware and have the same offsets, 4308 * we get off cheap. Note that if they're both naive, offset1 == 4309 * offset2 == 0 at this point. 4310 */ 4311 if (n1 == n2 && offset1 == offset2) { 4312 diff = memcmp(self->data, ((PyDateTime_DateTime *)other)->data, 4313 _PyDateTime_DATETIME_DATASIZE); 4314 return diff_to_bool(diff, op); 4315 } 4316 4317 if (n1 == OFFSET_AWARE && n2 == OFFSET_AWARE) { 4318 PyDateTime_Delta *delta; 4319 4320 assert(offset1 != offset2); /* else last "if" handled it */ 4321 delta = (PyDateTime_Delta *)datetime_subtract((PyObject *)self, 4322 other); 4323 if (delta == NULL) 4324 return NULL; 4325 diff = GET_TD_DAYS(delta); 4326 if (diff == 0) 4327 diff = GET_TD_SECONDS(delta) | 4328 GET_TD_MICROSECONDS(delta); 4329 Py_DECREF(delta); 4330 return diff_to_bool(diff, op); 4331 } 4332 4333 assert(n1 != n2); 4334 PyErr_SetString(PyExc_TypeError, 4335 "can't compare offset-naive and " 4336 "offset-aware datetimes"); 4337 return NULL; 4338 } 4339 4340 static long 4341 datetime_hash(PyDateTime_DateTime *self) 4342 { 4343 if (self->hashcode == -1) { 4344 naivety n; 4345 int offset; 4346 PyObject *temp; 4347 4348 n = classify_utcoffset((PyObject *)self, (PyObject *)self, 4349 &offset); 4350 assert(n != OFFSET_UNKNOWN); 4351 if (n == OFFSET_ERROR) 4352 return -1; 4353 4354 /* Reduce this to a hash of another object. */ 4355 if (n == OFFSET_NAIVE) 4356 temp = PyString_FromStringAndSize( 4357 (char *)self->data, 4358 _PyDateTime_DATETIME_DATASIZE); 4359 else { 4360 int days; 4361 int seconds; 4362 4363 assert(n == OFFSET_AWARE); 4364 assert(HASTZINFO(self)); 4365 days = ymd_to_ord(GET_YEAR(self), 4366 GET_MONTH(self), 4367 GET_DAY(self)); 4368 seconds = DATE_GET_HOUR(self) * 3600 + 4369 (DATE_GET_MINUTE(self) - offset) * 60 + 4370 DATE_GET_SECOND(self); 4371 temp = new_delta(days, 4372 seconds, 4373 DATE_GET_MICROSECOND(self), 4374 1); 4375 } 4376 if (temp != NULL) { 4377 self->hashcode = PyObject_Hash(temp); 4378 Py_DECREF(temp); 4379 } 4380 } 4381 return self->hashcode; 4382 } 4383 4384 static PyObject * 4385 datetime_replace(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) 4386 { 4387 PyObject *clone; 4388 PyObject *tuple; 4389 int y = GET_YEAR(self); 4390 int m = GET_MONTH(self); 4391 int d = GET_DAY(self); 4392 int hh = DATE_GET_HOUR(self); 4393 int mm = DATE_GET_MINUTE(self); 4394 int ss = DATE_GET_SECOND(self); 4395 int us = DATE_GET_MICROSECOND(self); 4396 PyObject *tzinfo = HASTZINFO(self) ? self->tzinfo : Py_None; 4397 4398 if (! PyArg_ParseTupleAndKeywords(args, kw, "|iiiiiiiO:replace", 4399 datetime_kws, 4400 &y, &m, &d, &hh, &mm, &ss, &us, 4401 &tzinfo)) 4402 return NULL; 4403 tuple = Py_BuildValue("iiiiiiiO", y, m, d, hh, mm, ss, us, tzinfo); 4404 if (tuple == NULL) 4405 return NULL; 4406 clone = datetime_new(Py_TYPE(self), tuple, NULL); 4407 Py_DECREF(tuple); 4408 return clone; 4409 } 4410 4411 static PyObject * 4412 datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) 4413 { 4414 int y, m, d, hh, mm, ss, us; 4415 PyObject *result; 4416 int offset, none; 4417 4418 PyObject *tzinfo; 4419 static char *keywords[] = {"tz", NULL}; 4420 4421 if (! PyArg_ParseTupleAndKeywords(args, kw, "O!:astimezone", keywords, 4422 &PyDateTime_TZInfoType, &tzinfo)) 4423 return NULL; 4424 4425 if (!HASTZINFO(self) || self->tzinfo == Py_None) 4426 goto NeedAware; 4427 4428 /* Conversion to self's own time zone is a NOP. */ 4429 if (self->tzinfo == tzinfo) { 4430 Py_INCREF(self); 4431 return (PyObject *)self; 4432 } 4433 4434 /* Convert self to UTC. */ 4435 offset = call_utcoffset(self->tzinfo, (PyObject *)self, &none); 4436 if (offset == -1 && PyErr_Occurred()) 4437 return NULL; 4438 if (none) 4439 goto NeedAware; 4440 4441 y = GET_YEAR(self); 4442 m = GET_MONTH(self); 4443 d = GET_DAY(self); 4444 hh = DATE_GET_HOUR(self); 4445 mm = DATE_GET_MINUTE(self); 4446 ss = DATE_GET_SECOND(self); 4447 us = DATE_GET_MICROSECOND(self); 4448 4449 mm -= offset; 4450 if ((mm < 0 || mm >= 60) && 4451 normalize_datetime(&y, &m, &d, &hh, &mm, &ss, &us) < 0) 4452 return NULL; 4453 4454 /* Attach new tzinfo and let fromutc() do the rest. */ 4455 result = new_datetime(y, m, d, hh, mm, ss, us, tzinfo); 4456 if (result != NULL) { 4457 PyObject *temp = result; 4458 4459 result = PyObject_CallMethod(tzinfo, "fromutc", "O", temp); 4460 Py_DECREF(temp); 4461 } 4462 return result; 4463 4464 NeedAware: 4465 PyErr_SetString(PyExc_ValueError, "astimezone() cannot be applied to " 4466 "a naive datetime"); 4467 return NULL; 4468 } 4469 4470 static PyObject * 4471 datetime_timetuple(PyDateTime_DateTime *self) 4472 { 4473 int dstflag = -1; 4474 4475 if (HASTZINFO(self) && self->tzinfo != Py_None) { 4476 int none; 4477 4478 dstflag = call_dst(self->tzinfo, (PyObject *)self, &none); 4479 if (dstflag == -1 && PyErr_Occurred()) 4480 return NULL; 4481 4482 if (none) 4483 dstflag = -1; 4484 else if (dstflag != 0) 4485 dstflag = 1; 4486 4487 } 4488 return build_struct_time(GET_YEAR(self), 4489 GET_MONTH(self), 4490 GET_DAY(self), 4491 DATE_GET_HOUR(self), 4492 DATE_GET_MINUTE(self), 4493 DATE_GET_SECOND(self), 4494 dstflag); 4495 } 4496 4497 static PyObject * 4498 datetime_getdate(PyDateTime_DateTime *self) 4499 { 4500 return new_date(GET_YEAR(self), 4501 GET_MONTH(self), 4502 GET_DAY(self)); 4503 } 4504 4505 static PyObject * 4506 datetime_gettime(PyDateTime_DateTime *self) 4507 { 4508 return new_time(DATE_GET_HOUR(self), 4509 DATE_GET_MINUTE(self), 4510 DATE_GET_SECOND(self), 4511 DATE_GET_MICROSECOND(self), 4512 Py_None); 4513 } 4514 4515 static PyObject * 4516 datetime_gettimetz(PyDateTime_DateTime *self) 4517 { 4518 return new_time(DATE_GET_HOUR(self), 4519 DATE_GET_MINUTE(self), 4520 DATE_GET_SECOND(self), 4521 DATE_GET_MICROSECOND(self), 4522 HASTZINFO(self) ? self->tzinfo : Py_None); 4523 } 4524 4525 static PyObject * 4526 datetime_utctimetuple(PyDateTime_DateTime *self) 4527 { 4528 int y = GET_YEAR(self); 4529 int m = GET_MONTH(self); 4530 int d = GET_DAY(self); 4531 int hh = DATE_GET_HOUR(self); 4532 int mm = DATE_GET_MINUTE(self); 4533 int ss = DATE_GET_SECOND(self); 4534 int us = 0; /* microseconds are ignored in a timetuple */ 4535 int offset = 0; 4536 4537 if (HASTZINFO(self) && self->tzinfo != Py_None) { 4538 int none; 4539 4540 offset = call_utcoffset(self->tzinfo, (PyObject *)self, &none); 4541 if (offset == -1 && PyErr_Occurred()) 4542 return NULL; 4543 } 4544 /* Even if offset is 0, don't call timetuple() -- tm_isdst should be 4545 * 0 in a UTC timetuple regardless of what dst() says. 4546 */ 4547 if (offset) { 4548 /* Subtract offset minutes & normalize. */ 4549 int stat; 4550 4551 mm -= offset; 4552 stat = normalize_datetime(&y, &m, &d, &hh, &mm, &ss, &us); 4553 if (stat < 0) { 4554 /* At the edges, it's possible we overflowed 4555 * beyond MINYEAR or MAXYEAR. 4556 */ 4557 if (PyErr_ExceptionMatches(PyExc_OverflowError)) 4558 PyErr_Clear(); 4559 else 4560 return NULL; 4561 } 4562 } 4563 return build_struct_time(y, m, d, hh, mm, ss, 0); 4564 } 4565 4566 /* Pickle support, a simple use of __reduce__. */ 4567 4568 /* Let basestate be the non-tzinfo data string. 4569 * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo). 4570 * So it's a tuple in any (non-error) case. 4571 * __getstate__ isn't exposed. 4572 */ 4573 static PyObject * 4574 datetime_getstate(PyDateTime_DateTime *self) 4575 { 4576 PyObject *basestate; 4577 PyObject *result = NULL; 4578 4579 basestate = PyString_FromStringAndSize((char *)self->data, 4580 _PyDateTime_DATETIME_DATASIZE); 4581 if (basestate != NULL) { 4582 if (! HASTZINFO(self) || self->tzinfo == Py_None) 4583 result = PyTuple_Pack(1, basestate); 4584 else 4585 result = PyTuple_Pack(2, basestate, self->tzinfo); 4586 Py_DECREF(basestate); 4587 } 4588 return result; 4589 } 4590 4591 static PyObject * 4592 datetime_reduce(PyDateTime_DateTime *self, PyObject *arg) 4593 { 4594 return Py_BuildValue("(ON)", Py_TYPE(self), datetime_getstate(self)); 4595 } 4596 4597 static PyMethodDef datetime_methods[] = { 4598 4599 /* Class methods: */ 4600 4601 {"now", (PyCFunction)datetime_now, 4602 METH_VARARGS | METH_KEYWORDS | METH_CLASS, 4603 PyDoc_STR("[tz] -> new datetime with tz's local day and time.")}, 4604 4605 {"utcnow", (PyCFunction)datetime_utcnow, 4606 METH_NOARGS | METH_CLASS, 4607 PyDoc_STR("Return a new datetime representing UTC day and time.")}, 4608 4609 {"fromtimestamp", (PyCFunction)datetime_fromtimestamp, 4610 METH_VARARGS | METH_KEYWORDS | METH_CLASS, 4611 PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")}, 4612 4613 {"utcfromtimestamp", (PyCFunction)datetime_utcfromtimestamp, 4614 METH_VARARGS | METH_CLASS, 4615 PyDoc_STR("timestamp -> UTC datetime from a POSIX timestamp " 4616 "(like time.time()).")}, 4617 4618 {"strptime", (PyCFunction)datetime_strptime, 4619 METH_VARARGS | METH_CLASS, 4620 PyDoc_STR("string, format -> new datetime parsed from a string " 4621 "(like time.strptime()).")}, 4622 4623 {"combine", (PyCFunction)datetime_combine, 4624 METH_VARARGS | METH_KEYWORDS | METH_CLASS, 4625 PyDoc_STR("date, time -> datetime with same date and time fields")}, 4626 4627 /* Instance methods: */ 4628 4629 {"date", (PyCFunction)datetime_getdate, METH_NOARGS, 4630 PyDoc_STR("Return date object with same year, month and day.")}, 4631 4632 {"time", (PyCFunction)datetime_gettime, METH_NOARGS, 4633 PyDoc_STR("Return time object with same time but with tzinfo=None.")}, 4634 4635 {"timetz", (PyCFunction)datetime_gettimetz, METH_NOARGS, 4636 PyDoc_STR("Return time object with same time and tzinfo.")}, 4637 4638 {"ctime", (PyCFunction)datetime_ctime, METH_NOARGS, 4639 PyDoc_STR("Return ctime() style string.")}, 4640 4641 {"timetuple", (PyCFunction)datetime_timetuple, METH_NOARGS, 4642 PyDoc_STR("Return time tuple, compatible with time.localtime().")}, 4643 4644 {"utctimetuple", (PyCFunction)datetime_utctimetuple, METH_NOARGS, 4645 PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")}, 4646 4647 {"isoformat", (PyCFunction)datetime_isoformat, METH_VARARGS | METH_KEYWORDS, 4648 PyDoc_STR("[sep] -> string in ISO 8601 format, " 4649 "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n" 4650 "sep is used to separate the year from the time, and " 4651 "defaults to 'T'.")}, 4652 4653 {"utcoffset", (PyCFunction)datetime_utcoffset, METH_NOARGS, 4654 PyDoc_STR("Return self.tzinfo.utcoffset(self).")}, 4655 4656 {"tzname", (PyCFunction)datetime_tzname, METH_NOARGS, 4657 PyDoc_STR("Return self.tzinfo.tzname(self).")}, 4658 4659 {"dst", (PyCFunction)datetime_dst, METH_NOARGS, 4660 PyDoc_STR("Return self.tzinfo.dst(self).")}, 4661 4662 {"replace", (PyCFunction)datetime_replace, METH_VARARGS | METH_KEYWORDS, 4663 PyDoc_STR("Return datetime with new specified fields.")}, 4664 4665 {"astimezone", (PyCFunction)datetime_astimezone, METH_VARARGS | METH_KEYWORDS, 4666 PyDoc_STR("tz -> convert to local time in new timezone tz\n")}, 4667 4668 {"__reduce__", (PyCFunction)datetime_reduce, METH_NOARGS, 4669 PyDoc_STR("__reduce__() -> (cls, state)")}, 4670 4671 {NULL, NULL} 4672 }; 4673 4674 static char datetime_doc[] = 4675 PyDoc_STR("datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\ 4676 \n\ 4677 The year, month and day arguments are required. tzinfo may be None, or an\n\ 4678 instance of a tzinfo subclass. The remaining arguments may be ints or longs.\n"); 4679 4680 static PyNumberMethods datetime_as_number = { 4681 datetime_add, /* nb_add */ 4682 datetime_subtract, /* nb_subtract */ 4683 0, /* nb_multiply */ 4684 0, /* nb_divide */ 4685 0, /* nb_remainder */ 4686 0, /* nb_divmod */ 4687 0, /* nb_power */ 4688 0, /* nb_negative */ 4689 0, /* nb_positive */ 4690 0, /* nb_absolute */ 4691 0, /* nb_nonzero */ 4692 }; 4693 4694 statichere PyTypeObject PyDateTime_DateTimeType = { 4695 PyObject_HEAD_INIT(NULL) 4696 0, /* ob_size */ 4697 "datetime.datetime", /* tp_name */ 4698 sizeof(PyDateTime_DateTime), /* tp_basicsize */ 4699 0, /* tp_itemsize */ 4700 (destructor)datetime_dealloc, /* tp_dealloc */ 4701 0, /* tp_print */ 4702 0, /* tp_getattr */ 4703 0, /* tp_setattr */ 4704 0, /* tp_compare */ 4705 (reprfunc)datetime_repr, /* tp_repr */ 4706 &datetime_as_number, /* tp_as_number */ 4707 0, /* tp_as_sequence */ 4708 0, /* tp_as_mapping */ 4709 (hashfunc)datetime_hash, /* tp_hash */ 4710 0, /* tp_call */ 4711 (reprfunc)datetime_str, /* tp_str */ 4712 PyObject_GenericGetAttr, /* tp_getattro */ 4713 0, /* tp_setattro */ 4714 0, /* tp_as_buffer */ 4715 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES | 4716 Py_TPFLAGS_BASETYPE, /* tp_flags */ 4717 datetime_doc, /* tp_doc */ 4718 0, /* tp_traverse */ 4719 0, /* tp_clear */ 4720 (richcmpfunc)datetime_richcompare, /* tp_richcompare */ 4721 0, /* tp_weaklistoffset */ 4722 0, /* tp_iter */ 4723 0, /* tp_iternext */ 4724 datetime_methods, /* tp_methods */ 4725 0, /* tp_members */ 4726 datetime_getset, /* tp_getset */ 4727 &PyDateTime_DateType, /* tp_base */ 4728 0, /* tp_dict */ 4729 0, /* tp_descr_get */ 4730 0, /* tp_descr_set */ 4731 0, /* tp_dictoffset */ 4732 0, /* tp_init */ 4733 datetime_alloc, /* tp_alloc */ 4734 datetime_new, /* tp_new */ 4735 0, /* tp_free */ 4736 }; 4737 4738 /* --------------------------------------------------------------------------- 4739 * Module methods and initialization. 4740 */ 4741 4742 static PyMethodDef module_methods[] = { 4743 {NULL, NULL} 4744 }; 4745 4746 /* C API. Clients get at this via PyDateTime_IMPORT, defined in 4747 * datetime.h. 4748 */ 4749 static PyDateTime_CAPI CAPI = { 4750 &PyDateTime_DateType, 4751 &PyDateTime_DateTimeType, 4752 &PyDateTime_TimeType, 4753 &PyDateTime_DeltaType, 4754 &PyDateTime_TZInfoType, 4755 new_date_ex, 4756 new_datetime_ex, 4757 new_time_ex, 4758 new_delta_ex, 4759 datetime_fromtimestamp, 4760 date_fromtimestamp 4761 }; 4762 4763 4764 PyMODINIT_FUNC 4765 initdatetime(void) 4766 { 4767 PyObject *m; /* a module object */ 4768 PyObject *d; /* its dict */ 4769 PyObject *x; 4770 4771 m = Py_InitModule3("datetime", module_methods, 4772 "Fast implementation of the datetime type."); 4773 if (m == NULL) 4774 return; 4775 4776 if (PyType_Ready(&PyDateTime_DateType) < 0) 4777 return; 4778 if (PyType_Ready(&PyDateTime_DateTimeType) < 0) 4779 return; 4780 if (PyType_Ready(&PyDateTime_DeltaType) < 0) 4781 return; 4782 if (PyType_Ready(&PyDateTime_TimeType) < 0) 4783 return; 4784 if (PyType_Ready(&PyDateTime_TZInfoType) < 0) 4785 return; 4786 4787 /* timedelta values */ 4788 d = PyDateTime_DeltaType.tp_dict; 4789 4790 x = new_delta(0, 0, 1, 0); 4791 if (x == NULL || PyDict_SetItemString(d, "resolution", x) < 0) 4792 return; 4793 Py_DECREF(x); 4794 4795 x = new_delta(-MAX_DELTA_DAYS, 0, 0, 0); 4796 if (x == NULL || PyDict_SetItemString(d, "min", x) < 0) 4797 return; 4798 Py_DECREF(x); 4799 4800 x = new_delta(MAX_DELTA_DAYS, 24*3600-1, 1000000-1, 0); 4801 if (x == NULL || PyDict_SetItemString(d, "max", x) < 0) 4802 return; 4803 Py_DECREF(x); 4804 4805 /* date values */ 4806 d = PyDateTime_DateType.tp_dict; 4807 4808 x = new_date(1, 1, 1); 4809 if (x == NULL || PyDict_SetItemString(d, "min", x) < 0) 4810 return; 4811 Py_DECREF(x); 4812 4813 x = new_date(MAXYEAR, 12, 31); 4814 if (x == NULL || PyDict_SetItemString(d, "max", x) < 0) 4815 return; 4816 Py_DECREF(x); 4817 4818 x = new_delta(1, 0, 0, 0); 4819 if (x == NULL || PyDict_SetItemString(d, "resolution", x) < 0) 4820 return; 4821 Py_DECREF(x); 4822 4823 /* time values */ 4824 d = PyDateTime_TimeType.tp_dict; 4825 4826 x = new_time(0, 0, 0, 0, Py_None); 4827 if (x == NULL || PyDict_SetItemString(d, "min", x) < 0) 4828 return; 4829 Py_DECREF(x); 4830 4831 x = new_time(23, 59, 59, 999999, Py_None); 4832 if (x == NULL || PyDict_SetItemString(d, "max", x) < 0) 4833 return; 4834 Py_DECREF(x); 4835 4836 x = new_delta(0, 0, 1, 0); 4837 if (x == NULL || PyDict_SetItemString(d, "resolution", x) < 0) 4838 return; 4839 Py_DECREF(x); 4840 4841 /* datetime values */ 4842 d = PyDateTime_DateTimeType.tp_dict; 4843 4844 x = new_datetime(1, 1, 1, 0, 0, 0, 0, Py_None); 4845 if (x == NULL || PyDict_SetItemString(d, "min", x) < 0) 4846 return; 4847 Py_DECREF(x); 4848 4849 x = new_datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, Py_None); 4850 if (x == NULL || PyDict_SetItemString(d, "max", x) < 0) 4851 return; 4852 Py_DECREF(x); 4853 4854 x = new_delta(0, 0, 1, 0); 4855 if (x == NULL || PyDict_SetItemString(d, "resolution", x) < 0) 4856 return; 4857 Py_DECREF(x); 4858 4859 /* module initialization */ 4860 PyModule_AddIntConstant(m, "MINYEAR", MINYEAR); 4861 PyModule_AddIntConstant(m, "MAXYEAR", MAXYEAR); 4862 4863 Py_INCREF(&PyDateTime_DateType); 4864 PyModule_AddObject(m, "date", (PyObject *) &PyDateTime_DateType); 4865 4866 Py_INCREF(&PyDateTime_DateTimeType); 4867 PyModule_AddObject(m, "datetime", 4868 (PyObject *)&PyDateTime_DateTimeType); 4869 4870 Py_INCREF(&PyDateTime_TimeType); 4871 PyModule_AddObject(m, "time", (PyObject *) &PyDateTime_TimeType); 4872 4873 Py_INCREF(&PyDateTime_DeltaType); 4874 PyModule_AddObject(m, "timedelta", (PyObject *) &PyDateTime_DeltaType); 4875 4876 Py_INCREF(&PyDateTime_TZInfoType); 4877 PyModule_AddObject(m, "tzinfo", (PyObject *) &PyDateTime_TZInfoType); 4878 4879 x = PyCapsule_New(&CAPI, PyDateTime_CAPSULE_NAME, NULL); 4880 if (x == NULL) 4881 return; 4882 PyModule_AddObject(m, "datetime_CAPI", x); 4883 4884 /* A 4-year cycle has an extra leap day over what we'd get from 4885 * pasting together 4 single years. 4886 */ 4887 assert(DI4Y == 4 * 365 + 1); 4888 assert(DI4Y == days_before_year(4+1)); 4889 4890 /* Similarly, a 400-year cycle has an extra leap day over what we'd 4891 * get from pasting together 4 100-year cycles. 4892 */ 4893 assert(DI400Y == 4 * DI100Y + 1); 4894 assert(DI400Y == days_before_year(400+1)); 4895 4896 /* OTOH, a 100-year cycle has one fewer leap day than we'd get from 4897 * pasting together 25 4-year cycles. 4898 */ 4899 assert(DI100Y == 25 * DI4Y - 1); 4900 assert(DI100Y == days_before_year(100+1)); 4901 4902 us_per_us = PyInt_FromLong(1); 4903 us_per_ms = PyInt_FromLong(1000); 4904 us_per_second = PyInt_FromLong(1000000); 4905 us_per_minute = PyInt_FromLong(60000000); 4906 seconds_per_day = PyInt_FromLong(24 * 3600); 4907 if (us_per_us == NULL || us_per_ms == NULL || us_per_second == NULL || 4908 us_per_minute == NULL || seconds_per_day == NULL) 4909 return; 4910 4911 /* The rest are too big for 32-bit ints, but even 4912 * us_per_week fits in 40 bits, so doubles should be exact. 4913 */ 4914 us_per_hour = PyLong_FromDouble(3600000000.0); 4915 us_per_day = PyLong_FromDouble(86400000000.0); 4916 us_per_week = PyLong_FromDouble(604800000000.0); 4917 if (us_per_hour == NULL || us_per_day == NULL || us_per_week == NULL) 4918 return; 4919 } 4920 4921 /* --------------------------------------------------------------------------- 4922 Some time zone algebra. For a datetime x, let 4923 x.n = x stripped of its timezone -- its naive time. 4924 x.o = x.utcoffset(), and assuming that doesn't raise an exception or 4925 return None 4926 x.d = x.dst(), and assuming that doesn't raise an exception or 4927 return None 4928 x.s = x's standard offset, x.o - x.d 4929 4930 Now some derived rules, where k is a duration (timedelta). 4931 4932 1. x.o = x.s + x.d 4933 This follows from the definition of x.s. 4934 4935 2. If x and y have the same tzinfo member, x.s = y.s. 4936 This is actually a requirement, an assumption we need to make about 4937 sane tzinfo classes. 4938 4939 3. The naive UTC time corresponding to x is x.n - x.o. 4940 This is again a requirement for a sane tzinfo class. 4941 4942 4. (x+k).s = x.s 4943 This follows from #2, and that datimetimetz+timedelta preserves tzinfo. 4944 4945 5. (x+k).n = x.n + k 4946 Again follows from how arithmetic is defined. 4947 4948 Now we can explain tz.fromutc(x). Let's assume it's an interesting case 4949 (meaning that the various tzinfo methods exist, and don't blow up or return 4950 None when called). 4951 4952 The function wants to return a datetime y with timezone tz, equivalent to x. 4953 x is already in UTC. 4954 4955 By #3, we want 4956 4957 y.n - y.o = x.n [1] 4958 4959 The algorithm starts by attaching tz to x.n, and calling that y. So 4960 x.n = y.n at the start. Then it wants to add a duration k to y, so that [1] 4961 becomes true; in effect, we want to solve [2] for k: 4962 4963 (y+k).n - (y+k).o = x.n [2] 4964 4965 By #1, this is the same as 4966 4967 (y+k).n - ((y+k).s + (y+k).d) = x.n [3] 4968 4969 By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start. 4970 Substituting that into [3], 4971 4972 x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving 4973 k - (y+k).s - (y+k).d = 0; rearranging, 4974 k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so 4975 k = y.s - (y+k).d 4976 4977 On the RHS, (y+k).d can't be computed directly, but y.s can be, and we 4978 approximate k by ignoring the (y+k).d term at first. Note that k can't be 4979 very large, since all offset-returning methods return a duration of magnitude 4980 less than 24 hours. For that reason, if y is firmly in std time, (y+k).d must 4981 be 0, so ignoring it has no consequence then. 4982 4983 In any case, the new value is 4984 4985 z = y + y.s [4] 4986 4987 It's helpful to step back at look at [4] from a higher level: it's simply 4988 mapping from UTC to tz's standard time. 4989 4990 At this point, if 4991 4992 z.n - z.o = x.n [5] 4993 4994 we have an equivalent time, and are almost done. The insecurity here is 4995 at the start of daylight time. Picture US Eastern for concreteness. The wall 4996 time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don't make good 4997 sense then. The docs ask that an Eastern tzinfo class consider such a time to 4998 be EDT (because it's "after 2"), which is a redundant spelling of 1:MM EST 4999 on the day DST starts. We want to return the 1:MM EST spelling because that's 5000 the only spelling that makes sense on the local wall clock. 5001 5002 In fact, if [5] holds at this point, we do have the standard-time spelling, 5003 but that takes a bit of proof. We first prove a stronger result. What's the 5004 difference between the LHS and RHS of [5]? Let 5005 5006 diff = x.n - (z.n - z.o) [6] 5007 5008 Now 5009 z.n = by [4] 5010 (y + y.s).n = by #5 5011 y.n + y.s = since y.n = x.n 5012 x.n + y.s = since z and y are have the same tzinfo member, 5013 y.s = z.s by #2 5014 x.n + z.s 5015 5016 Plugging that back into [6] gives 5017 5018 diff = 5019 x.n - ((x.n + z.s) - z.o) = expanding 5020 x.n - x.n - z.s + z.o = cancelling 5021 - z.s + z.o = by #2 5022 z.d 5023 5024 So diff = z.d. 5025 5026 If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time 5027 spelling we wanted in the endcase described above. We're done. Contrarily, 5028 if z.d = 0, then we have a UTC equivalent, and are also done. 5029 5030 If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to 5031 add to z (in effect, z is in tz's standard time, and we need to shift the 5032 local clock into tz's daylight time). 5033 5034 Let 5035 5036 z' = z + z.d = z + diff [7] 5037 5038 and we can again ask whether 5039 5040 z'.n - z'.o = x.n [8] 5041 5042 If so, we're done. If not, the tzinfo class is insane, according to the 5043 assumptions we've made. This also requires a bit of proof. As before, let's 5044 compute the difference between the LHS and RHS of [8] (and skipping some of 5045 the justifications for the kinds of substitutions we've done several times 5046 already): 5047 5048 diff' = x.n - (z'.n - z'.o) = replacing z'.n via [7] 5049 x.n - (z.n + diff - z'.o) = replacing diff via [6] 5050 x.n - (z.n + x.n - (z.n - z.o) - z'.o) = 5051 x.n - z.n - x.n + z.n - z.o + z'.o = cancel x.n 5052 - z.n + z.n - z.o + z'.o = cancel z.n 5053 - z.o + z'.o = #1 twice 5054 -z.s - z.d + z'.s + z'.d = z and z' have same tzinfo 5055 z'.d - z.d 5056 5057 So z' is UTC-equivalent to x iff z'.d = z.d at this point. If they are equal, 5058 we've found the UTC-equivalent so are done. In fact, we stop with [7] and 5059 return z', not bothering to compute z'.d. 5060 5061 How could z.d and z'd differ? z' = z + z.d [7], so merely moving z' by 5062 a dst() offset, and starting *from* a time already in DST (we know z.d != 0), 5063 would have to change the result dst() returns: we start in DST, and moving 5064 a little further into it takes us out of DST. 5065 5066 There isn't a sane case where this can happen. The closest it gets is at 5067 the end of DST, where there's an hour in UTC with no spelling in a hybrid 5068 tzinfo class. In US Eastern, that's 5:MM UTC = 0:MM EST = 1:MM EDT. During 5069 that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM 5070 UTC) because the docs insist on that, but 0:MM is taken as being in daylight 5071 time (4:MM UTC). There is no local time mapping to 5:MM UTC. The local 5072 clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in 5073 standard time. Since that's what the local clock *does*, we want to map both 5074 UTC hours 5:MM and 6:MM to 1:MM Eastern. The result is ambiguous 5075 in local time, but so it goes -- it's the way the local clock works. 5076 5077 When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0, 5078 so z=0:MM. z.d=60 (minutes) then, so [5] doesn't hold and we keep going. 5079 z' = z + z.d = 1:MM then, and z'.d=0, and z'.d - z.d = -60 != 0 so [8] 5080 (correctly) concludes that z' is not UTC-equivalent to x. 5081 5082 Because we know z.d said z was in daylight time (else [5] would have held and 5083 we would have stopped then), and we know z.d != z'.d (else [8] would have held 5084 and we would have stopped then), and there are only 2 possible values dst() can 5085 return in Eastern, it follows that z'.d must be 0 (which it is in the example, 5086 but the reasoning doesn't depend on the example -- it depends on there being 5087 two possible dst() outcomes, one zero and the other non-zero). Therefore 5088 z' must be in standard time, and is the spelling we want in this case. 5089 5090 Note again that z' is not UTC-equivalent as far as the hybrid tzinfo class is 5091 concerned (because it takes z' as being in standard time rather than the 5092 daylight time we intend here), but returning it gives the real-life "local 5093 clock repeats an hour" behavior when mapping the "unspellable" UTC hour into 5094 tz. 5095 5096 When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with 5097 the 1:MM standard time spelling we want. 5098 5099 So how can this break? One of the assumptions must be violated. Two 5100 possibilities: 5101 5102 1) [2] effectively says that y.s is invariant across all y belong to a given 5103 time zone. This isn't true if, for political reasons or continental drift, 5104 a region decides to change its base offset from UTC. 5105 5106 2) There may be versions of "double daylight" time where the tail end of 5107 the analysis gives up a step too early. I haven't thought about that 5108 enough to say. 5109 5110 In any case, it's clear that the default fromutc() is strong enough to handle 5111 "almost all" time zones: so long as the standard offset is invariant, it 5112 doesn't matter if daylight time transition points change from year to year, or 5113 if daylight time is skipped in some years; it doesn't matter how large or 5114 small dst() may get within its bounds; and it doesn't even matter if some 5115 perverse time zone returns a negative dst()). So a breaking case must be 5116 pretty bizarre, and a tzinfo subclass can override fromutc() if it is. 5117 --------------------------------------------------------------------------- */ 5118