No issues found
1 /* C implementation for the date/time type documented at
2 * http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage
3 */
4
5 #define PY_SSIZE_T_CLEAN
6
7 #include "Python.h"
8 #include "modsupport.h"
9 #include "structmember.h"
10
11 #include <time.h>
12
13 #include "timefuncs.h"
14
15 /* Differentiate between building the core module and building extension
16 * modules.
17 */
18 #ifndef Py_BUILD_CORE
19 #define Py_BUILD_CORE
20 #endif
21 #include "datetime.h"
22 #undef Py_BUILD_CORE
23
24 /* We require that C int be at least 32 bits, and use int virtually
25 * everywhere. In just a few cases we use a temp long, where a Python
26 * API returns a C long. In such cases, we have to ensure that the
27 * final result fits in a C int (this can be an issue on 64-bit boxes).
28 */
29 #if SIZEOF_INT < 4
30 # error "datetime.c requires that C int have at least 32 bits"
31 #endif
32
33 #define MINYEAR 1
34 #define MAXYEAR 9999
35 #define MAXORDINAL 3652059 /* date(9999,12,31).toordinal() */
36
37 /* Nine decimal digits is easy to communicate, and leaves enough room
38 * so that two delta days can be added w/o fear of overflowing a signed
39 * 32-bit int, and with plenty of room left over to absorb any possible
40 * carries from adding seconds.
41 */
42 #define MAX_DELTA_DAYS 999999999
43
44 /* Rename the long macros in datetime.h to more reasonable short names. */
45 #define GET_YEAR PyDateTime_GET_YEAR
46 #define GET_MONTH PyDateTime_GET_MONTH
47 #define GET_DAY PyDateTime_GET_DAY
48 #define DATE_GET_HOUR PyDateTime_DATE_GET_HOUR
49 #define DATE_GET_MINUTE PyDateTime_DATE_GET_MINUTE
50 #define DATE_GET_SECOND PyDateTime_DATE_GET_SECOND
51 #define DATE_GET_MICROSECOND PyDateTime_DATE_GET_MICROSECOND
52
53 /* Date accessors for date and datetime. */
54 #define SET_YEAR(o, v) (((o)->data[0] = ((v) & 0xff00) >> 8), \
55 ((o)->data[1] = ((v) & 0x00ff)))
56 #define SET_MONTH(o, v) (PyDateTime_GET_MONTH(o) = (v))
57 #define SET_DAY(o, v) (PyDateTime_GET_DAY(o) = (v))
58
59 /* Date/Time accessors for datetime. */
60 #define DATE_SET_HOUR(o, v) (PyDateTime_DATE_GET_HOUR(o) = (v))
61 #define DATE_SET_MINUTE(o, v) (PyDateTime_DATE_GET_MINUTE(o) = (v))
62 #define DATE_SET_SECOND(o, v) (PyDateTime_DATE_GET_SECOND(o) = (v))
63 #define DATE_SET_MICROSECOND(o, v) \
64 (((o)->data[7] = ((v) & 0xff0000) >> 16), \
65 ((o)->data[8] = ((v) & 0x00ff00) >> 8), \
66 ((o)->data[9] = ((v) & 0x0000ff)))
67
68 /* Time accessors for time. */
69 #define TIME_GET_HOUR PyDateTime_TIME_GET_HOUR
70 #define TIME_GET_MINUTE PyDateTime_TIME_GET_MINUTE
71 #define TIME_GET_SECOND PyDateTime_TIME_GET_SECOND
72 #define TIME_GET_MICROSECOND PyDateTime_TIME_GET_MICROSECOND
73 #define TIME_SET_HOUR(o, v) (PyDateTime_TIME_GET_HOUR(o) = (v))
74 #define TIME_SET_MINUTE(o, v) (PyDateTime_TIME_GET_MINUTE(o) = (v))
75 #define TIME_SET_SECOND(o, v) (PyDateTime_TIME_GET_SECOND(o) = (v))
76 #define TIME_SET_MICROSECOND(o, v) \
77 (((o)->data[3] = ((v) & 0xff0000) >> 16), \
78 ((o)->data[4] = ((v) & 0x00ff00) >> 8), \
79 ((o)->data[5] = ((v) & 0x0000ff)))
80
81 /* Delta accessors for timedelta. */
82 #define GET_TD_DAYS(o) (((PyDateTime_Delta *)(o))->days)
83 #define GET_TD_SECONDS(o) (((PyDateTime_Delta *)(o))->seconds)
84 #define GET_TD_MICROSECONDS(o) (((PyDateTime_Delta *)(o))->microseconds)
85
86 #define SET_TD_DAYS(o, v) ((o)->days = (v))
87 #define SET_TD_SECONDS(o, v) ((o)->seconds = (v))
88 #define SET_TD_MICROSECONDS(o, v) ((o)->microseconds = (v))
89
90 /* p is a pointer to a time or a datetime object; HASTZINFO(p) returns
91 * p->hastzinfo.
92 */
93 #define HASTZINFO(p) (((_PyDateTime_BaseTZInfo *)(p))->hastzinfo)
94
95 /* M is a char or int claiming to be a valid month. The macro is equivalent
96 * to the two-sided Python test
97 * 1 <= M <= 12
98 */
99 #define MONTH_IS_SANE(M) ((unsigned int)(M) - 1 < 12)
100
101 /* Forward declarations. */
102 static PyTypeObject PyDateTime_DateType;
103 static PyTypeObject PyDateTime_DateTimeType;
104 static PyTypeObject PyDateTime_DeltaType;
105 static PyTypeObject PyDateTime_TimeType;
106 static PyTypeObject PyDateTime_TZInfoType;
107
108 /* ---------------------------------------------------------------------------
109 * Math utilities.
110 */
111
112 /* k = i+j overflows iff k differs in sign from both inputs,
113 * iff k^i has sign bit set and k^j has sign bit set,
114 * iff (k^i)&(k^j) has sign bit set.
115 */
116 #define SIGNED_ADD_OVERFLOWED(RESULT, I, J) \
117 ((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0)
118
119 /* Compute Python divmod(x, y), returning the quotient and storing the
120 * remainder into *r. The quotient is the floor of x/y, and that's
121 * the real point of this. C will probably truncate instead (C99
122 * requires truncation; C89 left it implementation-defined).
123 * Simplification: we *require* that y > 0 here. That's appropriate
124 * for all the uses made of it. This simplifies the code and makes
125 * the overflow case impossible (divmod(LONG_MIN, -1) is the only
126 * overflow case).
127 */
128 static int
129 divmod(int x, int y, int *r)
130 {
131 int quo;
132
133 assert(y > 0);
134 quo = x / y;
135 *r = x - quo * y;
136 if (*r < 0) {
137 --quo;
138 *r += y;
139 }
140 assert(0 <= *r && *r < y);
141 return quo;
142 }
143
144 /* Round a double to the nearest long. |x| must be small enough to fit
145 * in a C long; this is not checked.
146 */
147 static long
148 round_to_long(double x)
149 {
150 if (x >= 0.0)
151 x = floor(x + 0.5);
152 else
153 x = ceil(x - 0.5);
154 return (long)x;
155 }
156
157 /* ---------------------------------------------------------------------------
158 * General calendrical helper functions
159 */
160
161 /* For each month ordinal in 1..12, the number of days in that month,
162 * and the number of days before that month in the same year. These
163 * are correct for non-leap years only.
164 */
165 static int _days_in_month[] = {
166 0, /* unused; this vector uses 1-based indexing */
167 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
168 };
169
170 static int _days_before_month[] = {
171 0, /* unused; this vector uses 1-based indexing */
172 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
173 };
174
175 /* year -> 1 if leap year, else 0. */
176 static int
177 is_leap(int year)
178 {
179 /* Cast year to unsigned. The result is the same either way, but
180 * C can generate faster code for unsigned mod than for signed
181 * mod (especially for % 4 -- a good compiler should just grab
182 * the last 2 bits when the LHS is unsigned).
183 */
184 const unsigned int ayear = (unsigned int)year;
185 return ayear % 4 == 0 && (ayear % 100 != 0 || ayear % 400 == 0);
186 }
187
188 /* year, month -> number of days in that month in that year */
189 static int
190 days_in_month(int year, int month)
191 {
192 assert(month >= 1);
193 assert(month <= 12);
194 if (month == 2 && is_leap(year))
195 return 29;
196 else
197 return _days_in_month[month];
198 }
199
200 /* year, month -> number of days in year preceeding first day of month */
201 static int
202 days_before_month(int year, int month)
203 {
204 int days;
205
206 assert(month >= 1);
207 assert(month <= 12);
208 days = _days_before_month[month];
209 if (month > 2 && is_leap(year))
210 ++days;
211 return days;
212 }
213
214 /* year -> number of days before January 1st of year. Remember that we
215 * start with year 1, so days_before_year(1) == 0.
216 */
217 static int
218 days_before_year(int year)
219 {
220 int y = year - 1;
221 /* This is incorrect if year <= 0; we really want the floor
222 * here. But so long as MINYEAR is 1, the smallest year this
223 * can see is 0 (this can happen in some normalization endcases),
224 * so we'll just special-case that.
225 */
226 assert (year >= 0);
227 if (y >= 0)
228 return y*365 + y/4 - y/100 + y/400;
229 else {
230 assert(y == -1);
231 return -366;
232 }
233 }
234
235 /* Number of days in 4, 100, and 400 year cycles. That these have
236 * the correct values is asserted in the module init function.
237 */
238 #define DI4Y 1461 /* days_before_year(5); days in 4 years */
239 #define DI100Y 36524 /* days_before_year(101); days in 100 years */
240 #define DI400Y 146097 /* days_before_year(401); days in 400 years */
241
242 /* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */
243 static void
244 ord_to_ymd(int ordinal, int *year, int *month, int *day)
245 {
246 int n, n1, n4, n100, n400, leapyear, preceding;
247
248 /* ordinal is a 1-based index, starting at 1-Jan-1. The pattern of
249 * leap years repeats exactly every 400 years. The basic strategy is
250 * to find the closest 400-year boundary at or before ordinal, then
251 * work with the offset from that boundary to ordinal. Life is much
252 * clearer if we subtract 1 from ordinal first -- then the values
253 * of ordinal at 400-year boundaries are exactly those divisible
254 * by DI400Y:
255 *
256 * D M Y n n-1
257 * -- --- ---- ---------- ----------------
258 * 31 Dec -400 -DI400Y -DI400Y -1
259 * 1 Jan -399 -DI400Y +1 -DI400Y 400-year boundary
260 * ...
261 * 30 Dec 000 -1 -2
262 * 31 Dec 000 0 -1
263 * 1 Jan 001 1 0 400-year boundary
264 * 2 Jan 001 2 1
265 * 3 Jan 001 3 2
266 * ...
267 * 31 Dec 400 DI400Y DI400Y -1
268 * 1 Jan 401 DI400Y +1 DI400Y 400-year boundary
269 */
270 assert(ordinal >= 1);
271 --ordinal;
272 n400 = ordinal / DI400Y;
273 n = ordinal % DI400Y;
274 *year = n400 * 400 + 1;
275
276 /* Now n is the (non-negative) offset, in days, from January 1 of
277 * year, to the desired date. Now compute how many 100-year cycles
278 * precede n.
279 * Note that it's possible for n100 to equal 4! In that case 4 full
280 * 100-year cycles precede the desired day, which implies the
281 * desired day is December 31 at the end of a 400-year cycle.
282 */
283 n100 = n / DI100Y;
284 n = n % DI100Y;
285
286 /* Now compute how many 4-year cycles precede it. */
287 n4 = n / DI4Y;
288 n = n % DI4Y;
289
290 /* And now how many single years. Again n1 can be 4, and again
291 * meaning that the desired day is December 31 at the end of the
292 * 4-year cycle.
293 */
294 n1 = n / 365;
295 n = n % 365;
296
297 *year += n100 * 100 + n4 * 4 + n1;
298 if (n1 == 4 || n100 == 4) {
299 assert(n == 0);
300 *year -= 1;
301 *month = 12;
302 *day = 31;
303 return;
304 }
305
306 /* Now the year is correct, and n is the offset from January 1. We
307 * find the month via an estimate that's either exact or one too
308 * large.
309 */
310 leapyear = n1 == 3 && (n4 != 24 || n100 == 3);
311 assert(leapyear == is_leap(*year));
312 *month = (n + 50) >> 5;
313 preceding = (_days_before_month[*month] + (*month > 2 && leapyear));
314 if (preceding > n) {
315 /* estimate is too large */
316 *month -= 1;
317 preceding -= days_in_month(*year, *month);
318 }
319 n -= preceding;
320 assert(0 <= n);
321 assert(n < days_in_month(*year, *month));
322
323 *day = n + 1;
324 }
325
326 /* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */
327 static int
328 ymd_to_ord(int year, int month, int day)
329 {
330 return days_before_year(year) + days_before_month(year, month) + day;
331 }
332
333 /* Day of week, where Monday==0, ..., Sunday==6. 1/1/1 was a Monday. */
334 static int
335 weekday(int year, int month, int day)
336 {
337 return (ymd_to_ord(year, month, day) + 6) % 7;
338 }
339
340 /* Ordinal of the Monday starting week 1 of the ISO year. Week 1 is the
341 * first calendar week containing a Thursday.
342 */
343 static int
344 iso_week1_monday(int year)
345 {
346 int first_day = ymd_to_ord(year, 1, 1); /* ord of 1/1 */
347 /* 0 if 1/1 is a Monday, 1 if a Tue, etc. */
348 int first_weekday = (first_day + 6) % 7;
349 /* ordinal of closest Monday at or before 1/1 */
350 int week1_monday = first_day - first_weekday;
351
352 if (first_weekday > 3) /* if 1/1 was Fri, Sat, Sun */
353 week1_monday += 7;
354 return week1_monday;
355 }
356
357 /* ---------------------------------------------------------------------------
358 * Range checkers.
359 */
360
361 /* Check that -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS. If so, return 0.
362 * If not, raise OverflowError and return -1.
363 */
364 static int
365 check_delta_day_range(int days)
366 {
367 if (-MAX_DELTA_DAYS <= days && days <= MAX_DELTA_DAYS)
368 return 0;
369 PyErr_Format(PyExc_OverflowError,
370 "days=%d; must have magnitude <= %d",
371 days, MAX_DELTA_DAYS);
372 return -1;
373 }
374
375 /* Check that date arguments are in range. Return 0 if they are. If they
376 * aren't, raise ValueError and return -1.
377 */
378 static int
379 check_date_args(int year, int month, int day)
380 {
381
382 if (year < MINYEAR || year > MAXYEAR) {
383 PyErr_SetString(PyExc_ValueError,
384 "year is out of range");
385 return -1;
386 }
387 if (month < 1 || month > 12) {
388 PyErr_SetString(PyExc_ValueError,
389 "month must be in 1..12");
390 return -1;
391 }
392 if (day < 1 || day > days_in_month(year, month)) {
393 PyErr_SetString(PyExc_ValueError,
394 "day is out of range for month");
395 return -1;
396 }
397 return 0;
398 }
399
400 /* Check that time arguments are in range. Return 0 if they are. If they
401 * aren't, raise ValueError and return -1.
402 */
403 static int
404 check_time_args(int h, int m, int s, int us)
405 {
406 if (h < 0 || h > 23) {
407 PyErr_SetString(PyExc_ValueError,
408 "hour must be in 0..23");
409 return -1;
410 }
411 if (m < 0 || m > 59) {
412 PyErr_SetString(PyExc_ValueError,
413 "minute must be in 0..59");
414 return -1;
415 }
416 if (s < 0 || s > 59) {
417 PyErr_SetString(PyExc_ValueError,
418 "second must be in 0..59");
419 return -1;
420 }
421 if (us < 0 || us > 999999) {
422 PyErr_SetString(PyExc_ValueError,
423 "microsecond must be in 0..999999");
424 return -1;
425 }
426 return 0;
427 }
428
429 /* ---------------------------------------------------------------------------
430 * Normalization utilities.
431 */
432
433 /* One step of a mixed-radix conversion. A "hi" unit is equivalent to
434 * factor "lo" units. factor must be > 0. If *lo is less than 0, or
435 * at least factor, enough of *lo is converted into "hi" units so that
436 * 0 <= *lo < factor. The input values must be such that int overflow
437 * is impossible.
438 */
439 static void
440 normalize_pair(int *hi, int *lo, int factor)
441 {
442 assert(factor > 0);
443 assert(lo != hi);
444 if (*lo < 0 || *lo >= factor) {
445 const int num_hi = divmod(*lo, factor, lo);
446 const int new_hi = *hi + num_hi;
447 assert(! SIGNED_ADD_OVERFLOWED(new_hi, *hi, num_hi));
448 *hi = new_hi;
449 }
450 assert(0 <= *lo && *lo < factor);
451 }
452
453 /* Fiddle days (d), seconds (s), and microseconds (us) so that
454 * 0 <= *s < 24*3600
455 * 0 <= *us < 1000000
456 * The input values must be such that the internals don't overflow.
457 * The way this routine is used, we don't get close.
458 */
459 static void
460 normalize_d_s_us(int *d, int *s, int *us)
461 {
462 if (*us < 0 || *us >= 1000000) {
463 normalize_pair(s, us, 1000000);
464 /* |s| can't be bigger than about
465 * |original s| + |original us|/1000000 now.
466 */
467
468 }
469 if (*s < 0 || *s >= 24*3600) {
470 normalize_pair(d, s, 24*3600);
471 /* |d| can't be bigger than about
472 * |original d| +
473 * (|original s| + |original us|/1000000) / (24*3600) now.
474 */
475 }
476 assert(0 <= *s && *s < 24*3600);
477 assert(0 <= *us && *us < 1000000);
478 }
479
480 /* Fiddle years (y), months (m), and days (d) so that
481 * 1 <= *m <= 12
482 * 1 <= *d <= days_in_month(*y, *m)
483 * The input values must be such that the internals don't overflow.
484 * The way this routine is used, we don't get close.
485 */
486 static int
487 normalize_y_m_d(int *y, int *m, int *d)
488 {
489 int dim; /* # of days in month */
490
491 /* This gets muddy: the proper range for day can't be determined
492 * without knowing the correct month and year, but if day is, e.g.,
493 * plus or minus a million, the current month and year values make
494 * no sense (and may also be out of bounds themselves).
495 * Saying 12 months == 1 year should be non-controversial.
496 */
497 if (*m < 1 || *m > 12) {
498 --*m;
499 normalize_pair(y, m, 12);
500 ++*m;
501 /* |y| can't be bigger than about
502 * |original y| + |original m|/12 now.
503 */
504 }
505 assert(1 <= *m && *m <= 12);
506
507 /* Now only day can be out of bounds (year may also be out of bounds
508 * for a datetime object, but we don't care about that here).
509 * If day is out of bounds, what to do is arguable, but at least the
510 * method here is principled and explainable.
511 */
512 dim = days_in_month(*y, *m);
513 if (*d < 1 || *d > dim) {
514 /* Move day-1 days from the first of the month. First try to
515 * get off cheap if we're only one day out of range
516 * (adjustments for timezone alone can't be worse than that).
517 */
518 if (*d == 0) {
519 --*m;
520 if (*m > 0)
521 *d = days_in_month(*y, *m);
522 else {
523 --*y;
524 *m = 12;
525 *d = 31;
526 }
527 }
528 else if (*d == dim + 1) {
529 /* move forward a day */
530 ++*m;
531 *d = 1;
532 if (*m > 12) {
533 *m = 1;
534 ++*y;
535 }
536 }
537 else {
538 int ordinal = ymd_to_ord(*y, *m, 1) +
539 *d - 1;
540 if (ordinal < 1 || ordinal > MAXORDINAL) {
541 goto error;
542 } else {
543 ord_to_ymd(ordinal, y, m, d);
544 return 0;
545 }
546 }
547 }
548 assert(*m > 0);
549 assert(*d > 0);
550 if (MINYEAR <= *y && *y <= MAXYEAR)
551 return 0;
552 error:
553 PyErr_SetString(PyExc_OverflowError,
554 "date value out of range");
555 return -1;
556
557 }
558
559 /* Fiddle out-of-bounds months and days so that the result makes some kind
560 * of sense. The parameters are both inputs and outputs. Returns < 0 on
561 * failure, where failure means the adjusted year is out of bounds.
562 */
563 static int
564 normalize_date(int *year, int *month, int *day)
565 {
566 return normalize_y_m_d(year, month, day);
567 }
568
569 /* Force all the datetime fields into range. The parameters are both
570 * inputs and outputs. Returns < 0 on error.
571 */
572 static int
573 normalize_datetime(int *year, int *month, int *day,
574 int *hour, int *minute, int *second,
575 int *microsecond)
576 {
577 normalize_pair(second, microsecond, 1000000);
578 normalize_pair(minute, second, 60);
579 normalize_pair(hour, minute, 60);
580 normalize_pair(day, hour, 24);
581 return normalize_date(year, month, day);
582 }
583
584 /* ---------------------------------------------------------------------------
585 * Basic object allocation: tp_alloc implementations. These allocate
586 * Python objects of the right size and type, and do the Python object-
587 * initialization bit. If there's not enough memory, they return NULL after
588 * setting MemoryError. All data members remain uninitialized trash.
589 *
590 * We abuse the tp_alloc "nitems" argument to communicate whether a tzinfo
591 * member is needed. This is ugly, imprecise, and possibly insecure.
592 * tp_basicsize for the time and datetime types is set to the size of the
593 * struct that has room for the tzinfo member, so subclasses in Python will
594 * allocate enough space for a tzinfo member whether or not one is actually
595 * needed. That's the "ugly and imprecise" parts. The "possibly insecure"
596 * part is that PyType_GenericAlloc() (which subclasses in Python end up
597 * using) just happens today to effectively ignore the nitems argument
598 * when tp_itemsize is 0, which it is for these type objects. If that
599 * changes, perhaps the callers of tp_alloc slots in this file should
600 * be changed to force a 0 nitems argument unless the type being allocated
601 * is a base type implemented in this file (so that tp_alloc is time_alloc
602 * or datetime_alloc below, which know about the nitems abuse).
603 */
604
605 static PyObject *
606 time_alloc(PyTypeObject *type, Py_ssize_t aware)
607 {
608 PyObject *self;
609
610 self = (PyObject *)
611 PyObject_MALLOC(aware ?
612 sizeof(PyDateTime_Time) :
613 sizeof(_PyDateTime_BaseTime));
614 if (self == NULL)
615 return (PyObject *)PyErr_NoMemory();
616 PyObject_INIT(self, type);
617 return self;
618 }
619
620 static PyObject *
621 datetime_alloc(PyTypeObject *type, Py_ssize_t aware)
622 {
623 PyObject *self;
624
625 self = (PyObject *)
626 PyObject_MALLOC(aware ?
627 sizeof(PyDateTime_DateTime) :
628 sizeof(_PyDateTime_BaseDateTime));
629 if (self == NULL)
630 return (PyObject *)PyErr_NoMemory();
631 PyObject_INIT(self, type);
632 return self;
633 }
634
635 /* ---------------------------------------------------------------------------
636 * Helpers for setting object fields. These work on pointers to the
637 * appropriate base class.
638 */
639
640 /* For date and datetime. */
641 static void
642 set_date_fields(PyDateTime_Date *self, int y, int m, int d)
643 {
644 self->hashcode = -1;
645 SET_YEAR(self, y);
646 SET_MONTH(self, m);
647 SET_DAY(self, d);
648 }
649
650 /* ---------------------------------------------------------------------------
651 * Create various objects, mostly without range checking.
652 */
653
654 /* Create a date instance with no range checking. */
655 static PyObject *
656 new_date_ex(int year, int month, int day, PyTypeObject *type)
657 {
658 PyDateTime_Date *self;
659
660 self = (PyDateTime_Date *) (type->tp_alloc(type, 0));
661 if (self != NULL)
662 set_date_fields(self, year, month, day);
663 return (PyObject *) self;
664 }
665
666 #define new_date(year, month, day) \
667 new_date_ex(year, month, day, &PyDateTime_DateType)
668
669 /* Create a datetime instance with no range checking. */
670 static PyObject *
671 new_datetime_ex(int year, int month, int day, int hour, int minute,
672 int second, int usecond, PyObject *tzinfo, PyTypeObject *type)
673 {
674 PyDateTime_DateTime *self;
675 char aware = tzinfo != Py_None;
676
677 self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware));
678 if (self != NULL) {
679 self->hastzinfo = aware;
680 set_date_fields((PyDateTime_Date *)self, year, month, day);
681 DATE_SET_HOUR(self, hour);
682 DATE_SET_MINUTE(self, minute);
683 DATE_SET_SECOND(self, second);
684 DATE_SET_MICROSECOND(self, usecond);
685 if (aware) {
686 Py_INCREF(tzinfo);
687 self->tzinfo = tzinfo;
688 }
689 }
690 return (PyObject *)self;
691 }
692
693 #define new_datetime(y, m, d, hh, mm, ss, us, tzinfo) \
694 new_datetime_ex(y, m, d, hh, mm, ss, us, tzinfo, \
695 &PyDateTime_DateTimeType)
696
697 /* Create a time instance with no range checking. */
698 static PyObject *
699 new_time_ex(int hour, int minute, int second, int usecond,
700 PyObject *tzinfo, PyTypeObject *type)
701 {
702 PyDateTime_Time *self;
703 char aware = tzinfo != Py_None;
704
705 self = (PyDateTime_Time *) (type->tp_alloc(type, aware));
706 if (self != NULL) {
707 self->hastzinfo = aware;
708 self->hashcode = -1;
709 TIME_SET_HOUR(self, hour);
710 TIME_SET_MINUTE(self, minute);
711 TIME_SET_SECOND(self, second);
712 TIME_SET_MICROSECOND(self, usecond);
713 if (aware) {
714 Py_INCREF(tzinfo);
715 self->tzinfo = tzinfo;
716 }
717 }
718 return (PyObject *)self;
719 }
720
721 #define new_time(hh, mm, ss, us, tzinfo) \
722 new_time_ex(hh, mm, ss, us, tzinfo, &PyDateTime_TimeType)
723
724 /* Create a timedelta instance. Normalize the members iff normalize is
725 * true. Passing false is a speed optimization, if you know for sure
726 * that seconds and microseconds are already in their proper ranges. In any
727 * case, raises OverflowError and returns NULL if the normalized days is out
728 * of range).
729 */
730 static PyObject *
731 new_delta_ex(int days, int seconds, int microseconds, int normalize,
732 PyTypeObject *type)
733 {
734 PyDateTime_Delta *self;
735
736 if (normalize)
737 normalize_d_s_us(&days, &seconds, µ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 --------------------------------------------------------------------------- */