File: | Modules/_datetimemodule.c |
Location: | line 1554, column 9 |
Description: | Both operands to '!=' always have the same value |
1 | /* C implementation for the date/time type documented at | ||
2 | * http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage | ||
3 | */ | ||
4 | |||
5 | #include "Python.h" | ||
6 | #include "structmember.h" | ||
7 | |||
8 | #include <time.h> | ||
9 | |||
10 | #include "_time.h" | ||
11 | |||
12 | /* Differentiate between building the core module and building extension | ||
13 | * modules. | ||
14 | */ | ||
15 | #ifndef Py_BUILD_CORE | ||
16 | #define Py_BUILD_CORE | ||
17 | #endif | ||
18 | #include "datetime.h" | ||
19 | #undef Py_BUILD_CORE | ||
20 | |||
21 | /* We require that C int be at least 32 bits, and use int virtually | ||
22 | * everywhere. In just a few cases we use a temp long, where a Python | ||
23 | * API returns a C long. In such cases, we have to ensure that the | ||
24 | * final result fits in a C int (this can be an issue on 64-bit boxes). | ||
25 | */ | ||
26 | #if SIZEOF_INT4 < 4 | ||
27 | # error "_datetime.c requires that C int have at least 32 bits" | ||
28 | #endif | ||
29 | |||
30 | #define MINYEAR1 1 | ||
31 | #define MAXYEAR9999 9999 | ||
32 | #define MAXORDINAL3652059 3652059 /* date(9999,12,31).toordinal() */ | ||
33 | |||
34 | /* Nine decimal digits is easy to communicate, and leaves enough room | ||
35 | * so that two delta days can be added w/o fear of overflowing a signed | ||
36 | * 32-bit int, and with plenty of room left over to absorb any possible | ||
37 | * carries from adding seconds. | ||
38 | */ | ||
39 | #define MAX_DELTA_DAYS999999999 999999999 | ||
40 | |||
41 | /* Rename the long macros in datetime.h to more reasonable short names. */ | ||
42 | #define GET_YEARPyDateTime_GET_YEAR PyDateTime_GET_YEAR | ||
43 | #define GET_MONTHPyDateTime_GET_MONTH PyDateTime_GET_MONTH | ||
44 | #define GET_DAYPyDateTime_GET_DAY PyDateTime_GET_DAY | ||
45 | #define DATE_GET_HOURPyDateTime_DATE_GET_HOUR PyDateTime_DATE_GET_HOUR | ||
46 | #define DATE_GET_MINUTEPyDateTime_DATE_GET_MINUTE PyDateTime_DATE_GET_MINUTE | ||
47 | #define DATE_GET_SECONDPyDateTime_DATE_GET_SECOND PyDateTime_DATE_GET_SECOND | ||
48 | #define DATE_GET_MICROSECONDPyDateTime_DATE_GET_MICROSECOND PyDateTime_DATE_GET_MICROSECOND | ||
49 | |||
50 | /* Date accessors for date and datetime. */ | ||
51 | #define SET_YEAR(o, v)(((o)->data[0] = ((v) & 0xff00) >> 8), ((o)-> data[1] = ((v) & 0x00ff))) (((o)->data[0] = ((v) & 0xff00) >> 8), \ | ||
52 | ((o)->data[1] = ((v) & 0x00ff))) | ||
53 | #define SET_MONTH(o, v)((((PyDateTime_Date*)o)->data[2]) = (v)) (PyDateTime_GET_MONTH(o)(((PyDateTime_Date*)o)->data[2]) = (v)) | ||
54 | #define SET_DAY(o, v)((((PyDateTime_Date*)o)->data[3]) = (v)) (PyDateTime_GET_DAY(o)(((PyDateTime_Date*)o)->data[3]) = (v)) | ||
55 | |||
56 | /* Date/Time accessors for datetime. */ | ||
57 | #define DATE_SET_HOUR(o, v)((((PyDateTime_DateTime*)o)->data[4]) = (v)) (PyDateTime_DATE_GET_HOUR(o)(((PyDateTime_DateTime*)o)->data[4]) = (v)) | ||
58 | #define DATE_SET_MINUTE(o, v)((((PyDateTime_DateTime*)o)->data[5]) = (v)) (PyDateTime_DATE_GET_MINUTE(o)(((PyDateTime_DateTime*)o)->data[5]) = (v)) | ||
59 | #define DATE_SET_SECOND(o, v)((((PyDateTime_DateTime*)o)->data[6]) = (v)) (PyDateTime_DATE_GET_SECOND(o)(((PyDateTime_DateTime*)o)->data[6]) = (v)) | ||
60 | #define DATE_SET_MICROSECOND(o, v)(((o)->data[7] = ((v) & 0xff0000) >> 16), ((o)-> data[8] = ((v) & 0x00ff00) >> 8), ((o)->data[9] = ((v) & 0x0000ff))) \ | ||
61 | (((o)->data[7] = ((v) & 0xff0000) >> 16), \ | ||
62 | ((o)->data[8] = ((v) & 0x00ff00) >> 8), \ | ||
63 | ((o)->data[9] = ((v) & 0x0000ff))) | ||
64 | |||
65 | /* Time accessors for time. */ | ||
66 | #define TIME_GET_HOURPyDateTime_TIME_GET_HOUR PyDateTime_TIME_GET_HOUR | ||
67 | #define TIME_GET_MINUTEPyDateTime_TIME_GET_MINUTE PyDateTime_TIME_GET_MINUTE | ||
68 | #define TIME_GET_SECONDPyDateTime_TIME_GET_SECOND PyDateTime_TIME_GET_SECOND | ||
69 | #define TIME_GET_MICROSECONDPyDateTime_TIME_GET_MICROSECOND PyDateTime_TIME_GET_MICROSECOND | ||
70 | #define TIME_SET_HOUR(o, v)((((PyDateTime_Time*)o)->data[0]) = (v)) (PyDateTime_TIME_GET_HOUR(o)(((PyDateTime_Time*)o)->data[0]) = (v)) | ||
71 | #define TIME_SET_MINUTE(o, v)((((PyDateTime_Time*)o)->data[1]) = (v)) (PyDateTime_TIME_GET_MINUTE(o)(((PyDateTime_Time*)o)->data[1]) = (v)) | ||
72 | #define TIME_SET_SECOND(o, v)((((PyDateTime_Time*)o)->data[2]) = (v)) (PyDateTime_TIME_GET_SECOND(o)(((PyDateTime_Time*)o)->data[2]) = (v)) | ||
73 | #define TIME_SET_MICROSECOND(o, v)(((o)->data[3] = ((v) & 0xff0000) >> 16), ((o)-> data[4] = ((v) & 0x00ff00) >> 8), ((o)->data[5] = ((v) & 0x0000ff))) \ | ||
74 | (((o)->data[3] = ((v) & 0xff0000) >> 16), \ | ||
75 | ((o)->data[4] = ((v) & 0x00ff00) >> 8), \ | ||
76 | ((o)->data[5] = ((v) & 0x0000ff))) | ||
77 | |||
78 | /* Delta accessors for timedelta. */ | ||
79 | #define GET_TD_DAYS(o)(((PyDateTime_Delta *)(o))->days) (((PyDateTime_Delta *)(o))->days) | ||
80 | #define GET_TD_SECONDS(o)(((PyDateTime_Delta *)(o))->seconds) (((PyDateTime_Delta *)(o))->seconds) | ||
81 | #define GET_TD_MICROSECONDS(o)(((PyDateTime_Delta *)(o))->microseconds) (((PyDateTime_Delta *)(o))->microseconds) | ||
82 | |||
83 | #define SET_TD_DAYS(o, v)((o)->days = (v)) ((o)->days = (v)) | ||
84 | #define SET_TD_SECONDS(o, v)((o)->seconds = (v)) ((o)->seconds = (v)) | ||
85 | #define SET_TD_MICROSECONDS(o, v)((o)->microseconds = (v)) ((o)->microseconds = (v)) | ||
86 | |||
87 | /* p is a pointer to a time or a datetime object; HASTZINFO(p) returns | ||
88 | * p->hastzinfo. | ||
89 | */ | ||
90 | #define HASTZINFO(p)(((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) (((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) | ||
91 | #define GET_TIME_TZINFO(p)((((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) ? ((PyDateTime_Time *)(p))->tzinfo : (&_Py_NoneStruct)) (HASTZINFO(p)(((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) ? \ | ||
92 | ((PyDateTime_Time *)(p))->tzinfo : Py_None(&_Py_NoneStruct)) | ||
93 | #define GET_DT_TZINFO(p)((((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) ? ((PyDateTime_DateTime *)(p))->tzinfo : (&_Py_NoneStruct)) (HASTZINFO(p)(((_PyDateTime_BaseTZInfo *)(p))->hastzinfo) ? \ | ||
94 | ((PyDateTime_DateTime *)(p))->tzinfo : Py_None(&_Py_NoneStruct)) | ||
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) ((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 | static PyTypeObject PyDateTime_TimeZoneType; | ||
108 | |||
109 | /* --------------------------------------------------------------------------- | ||
110 | * Math utilities. | ||
111 | */ | ||
112 | |||
113 | /* k = i+j overflows iff k differs in sign from both inputs, | ||
114 | * iff k^i has sign bit set and k^j has sign bit set, | ||
115 | * iff (k^i)&(k^j) has sign bit set. | ||
116 | */ | ||
117 | #define SIGNED_ADD_OVERFLOWED(RESULT, I, J)((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0) \ | ||
118 | ((((RESULT) ^ (I)) & ((RESULT) ^ (J))) < 0) | ||
119 | |||
120 | /* Compute Python divmod(x, y), returning the quotient and storing the | ||
121 | * remainder into *r. The quotient is the floor of x/y, and that's | ||
122 | * the real point of this. C will probably truncate instead (C99 | ||
123 | * requires truncation; C89 left it implementation-defined). | ||
124 | * Simplification: we *require* that y > 0 here. That's appropriate | ||
125 | * for all the uses made of it. This simplifies the code and makes | ||
126 | * the overflow case impossible (divmod(LONG_MIN, -1) is the only | ||
127 | * overflow case). | ||
128 | */ | ||
129 | static int | ||
130 | divmod(int x, int y, int *r) | ||
131 | { | ||
132 | int quo; | ||
133 | |||
134 | assert(y > 0)(__builtin_expect(!(y > 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 134, "y > 0") : (void)0); | ||
135 | quo = x / y; | ||
136 | *r = x - quo * y; | ||
137 | if (*r < 0) { | ||
138 | --quo; | ||
139 | *r += y; | ||
140 | } | ||
141 | assert(0 <= *r && *r < y)(__builtin_expect(!(0 <= *r && *r < y), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 141, "0 <= *r && *r < y") : (void)0); | ||
142 | return quo; | ||
143 | } | ||
144 | |||
145 | /* Round a double to the nearest long. |x| must be small enough to fit | ||
146 | * in a C long; this is not checked. | ||
147 | */ | ||
148 | static long | ||
149 | round_to_long(double x) | ||
150 | { | ||
151 | if (x >= 0.0) | ||
152 | x = floor(x + 0.5); | ||
153 | else | ||
154 | x = ceil(x - 0.5); | ||
155 | return (long)x; | ||
156 | } | ||
157 | |||
158 | /* Nearest integer to m / n for integers m and n. Half-integer results | ||
159 | * are rounded to even. | ||
160 | */ | ||
161 | static PyObject * | ||
162 | divide_nearest(PyObject *m, PyObject *n) | ||
163 | { | ||
164 | PyObject *result; | ||
165 | PyObject *temp; | ||
166 | |||
167 | temp = _PyLong_DivmodNear(m, n); | ||
168 | if (temp == NULL((void*)0)) | ||
169 | return NULL((void*)0); | ||
170 | result = PyTuple_GET_ITEM(temp, 0)(((PyTupleObject *)(temp))->ob_item[0]); | ||
171 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
172 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 172, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)(temp )); } while (0); | ||
173 | |||
174 | return result; | ||
175 | } | ||
176 | |||
177 | /* --------------------------------------------------------------------------- | ||
178 | * General calendrical helper functions | ||
179 | */ | ||
180 | |||
181 | /* For each month ordinal in 1..12, the number of days in that month, | ||
182 | * and the number of days before that month in the same year. These | ||
183 | * are correct for non-leap years only. | ||
184 | */ | ||
185 | static int _days_in_month[] = { | ||
186 | 0, /* unused; this vector uses 1-based indexing */ | ||
187 | 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 | ||
188 | }; | ||
189 | |||
190 | static int _days_before_month[] = { | ||
191 | 0, /* unused; this vector uses 1-based indexing */ | ||
192 | 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 | ||
193 | }; | ||
194 | |||
195 | /* year -> 1 if leap year, else 0. */ | ||
196 | static int | ||
197 | is_leap(int year) | ||
198 | { | ||
199 | /* Cast year to unsigned. The result is the same either way, but | ||
200 | * C can generate faster code for unsigned mod than for signed | ||
201 | * mod (especially for % 4 -- a good compiler should just grab | ||
202 | * the last 2 bits when the LHS is unsigned). | ||
203 | */ | ||
204 | const unsigned int ayear = (unsigned int)year; | ||
205 | return ayear % 4 == 0 && (ayear % 100 != 0 || ayear % 400 == 0); | ||
206 | } | ||
207 | |||
208 | /* year, month -> number of days in that month in that year */ | ||
209 | static int | ||
210 | days_in_month(int year, int month) | ||
211 | { | ||
212 | assert(month >= 1)(__builtin_expect(!(month >= 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 212, "month >= 1") : (void)0); | ||
213 | assert(month <= 12)(__builtin_expect(!(month <= 12), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 213, "month <= 12") : (void)0); | ||
214 | if (month == 2 && is_leap(year)) | ||
215 | return 29; | ||
216 | else | ||
217 | return _days_in_month[month]; | ||
218 | } | ||
219 | |||
220 | /* year, month -> number of days in year preceeding first day of month */ | ||
221 | static int | ||
222 | days_before_month(int year, int month) | ||
223 | { | ||
224 | int days; | ||
225 | |||
226 | assert(month >= 1)(__builtin_expect(!(month >= 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 226, "month >= 1") : (void)0); | ||
227 | assert(month <= 12)(__builtin_expect(!(month <= 12), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 227, "month <= 12") : (void)0); | ||
228 | days = _days_before_month[month]; | ||
229 | if (month > 2 && is_leap(year)) | ||
230 | ++days; | ||
231 | return days; | ||
232 | } | ||
233 | |||
234 | /* year -> number of days before January 1st of year. Remember that we | ||
235 | * start with year 1, so days_before_year(1) == 0. | ||
236 | */ | ||
237 | static int | ||
238 | days_before_year(int year) | ||
239 | { | ||
240 | int y = year - 1; | ||
241 | /* This is incorrect if year <= 0; we really want the floor | ||
242 | * here. But so long as MINYEAR is 1, the smallest year this | ||
243 | * can see is 1. | ||
244 | */ | ||
245 | assert (year >= 1)(__builtin_expect(!(year >= 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 245, "year >= 1") : (void)0); | ||
246 | return y*365 + y/4 - y/100 + y/400; | ||
247 | } | ||
248 | |||
249 | /* Number of days in 4, 100, and 400 year cycles. That these have | ||
250 | * the correct values is asserted in the module init function. | ||
251 | */ | ||
252 | #define DI4Y1461 1461 /* days_before_year(5); days in 4 years */ | ||
253 | #define DI100Y36524 36524 /* days_before_year(101); days in 100 years */ | ||
254 | #define DI400Y146097 146097 /* days_before_year(401); days in 400 years */ | ||
255 | |||
256 | /* ordinal -> year, month, day, considering 01-Jan-0001 as day 1. */ | ||
257 | static void | ||
258 | ord_to_ymd(int ordinal, int *year, int *month, int *day) | ||
259 | { | ||
260 | int n, n1, n4, n100, n400, leapyear, preceding; | ||
261 | |||
262 | /* ordinal is a 1-based index, starting at 1-Jan-1. The pattern of | ||
263 | * leap years repeats exactly every 400 years. The basic strategy is | ||
264 | * to find the closest 400-year boundary at or before ordinal, then | ||
265 | * work with the offset from that boundary to ordinal. Life is much | ||
266 | * clearer if we subtract 1 from ordinal first -- then the values | ||
267 | * of ordinal at 400-year boundaries are exactly those divisible | ||
268 | * by DI400Y: | ||
269 | * | ||
270 | * D M Y n n-1 | ||
271 | * -- --- ---- ---------- ---------------- | ||
272 | * 31 Dec -400 -DI400Y -DI400Y -1 | ||
273 | * 1 Jan -399 -DI400Y +1 -DI400Y 400-year boundary | ||
274 | * ... | ||
275 | * 30 Dec 000 -1 -2 | ||
276 | * 31 Dec 000 0 -1 | ||
277 | * 1 Jan 001 1 0 400-year boundary | ||
278 | * 2 Jan 001 2 1 | ||
279 | * 3 Jan 001 3 2 | ||
280 | * ... | ||
281 | * 31 Dec 400 DI400Y DI400Y -1 | ||
282 | * 1 Jan 401 DI400Y +1 DI400Y 400-year boundary | ||
283 | */ | ||
284 | assert(ordinal >= 1)(__builtin_expect(!(ordinal >= 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 284, "ordinal >= 1") : (void)0); | ||
285 | --ordinal; | ||
286 | n400 = ordinal / DI400Y146097; | ||
287 | n = ordinal % DI400Y146097; | ||
288 | *year = n400 * 400 + 1; | ||
289 | |||
290 | /* Now n is the (non-negative) offset, in days, from January 1 of | ||
291 | * year, to the desired date. Now compute how many 100-year cycles | ||
292 | * precede n. | ||
293 | * Note that it's possible for n100 to equal 4! In that case 4 full | ||
294 | * 100-year cycles precede the desired day, which implies the | ||
295 | * desired day is December 31 at the end of a 400-year cycle. | ||
296 | */ | ||
297 | n100 = n / DI100Y36524; | ||
298 | n = n % DI100Y36524; | ||
299 | |||
300 | /* Now compute how many 4-year cycles precede it. */ | ||
301 | n4 = n / DI4Y1461; | ||
302 | n = n % DI4Y1461; | ||
303 | |||
304 | /* And now how many single years. Again n1 can be 4, and again | ||
305 | * meaning that the desired day is December 31 at the end of the | ||
306 | * 4-year cycle. | ||
307 | */ | ||
308 | n1 = n / 365; | ||
309 | n = n % 365; | ||
310 | |||
311 | *year += n100 * 100 + n4 * 4 + n1; | ||
312 | if (n1 == 4 || n100 == 4) { | ||
313 | assert(n == 0)(__builtin_expect(!(n == 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 313, "n == 0") : (void)0); | ||
314 | *year -= 1; | ||
315 | *month = 12; | ||
316 | *day = 31; | ||
317 | return; | ||
318 | } | ||
319 | |||
320 | /* Now the year is correct, and n is the offset from January 1. We | ||
321 | * find the month via an estimate that's either exact or one too | ||
322 | * large. | ||
323 | */ | ||
324 | leapyear = n1 == 3 && (n4 != 24 || n100 == 3); | ||
325 | assert(leapyear == is_leap(*year))(__builtin_expect(!(leapyear == is_leap(*year)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 325, "leapyear == is_leap(*year)") : (void)0); | ||
326 | *month = (n + 50) >> 5; | ||
327 | preceding = (_days_before_month[*month] + (*month > 2 && leapyear)); | ||
328 | if (preceding > n) { | ||
329 | /* estimate is too large */ | ||
330 | *month -= 1; | ||
331 | preceding -= days_in_month(*year, *month); | ||
332 | } | ||
333 | n -= preceding; | ||
334 | assert(0 <= n)(__builtin_expect(!(0 <= n), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 334, "0 <= n") : (void)0); | ||
335 | assert(n < days_in_month(*year, *month))(__builtin_expect(!(n < days_in_month(*year, *month)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 335, "n < days_in_month(*year, *month)") : (void)0); | ||
336 | |||
337 | *day = n + 1; | ||
338 | } | ||
339 | |||
340 | /* year, month, day -> ordinal, considering 01-Jan-0001 as day 1. */ | ||
341 | static int | ||
342 | ymd_to_ord(int year, int month, int day) | ||
343 | { | ||
344 | return days_before_year(year) + days_before_month(year, month) + day; | ||
345 | } | ||
346 | |||
347 | /* Day of week, where Monday==0, ..., Sunday==6. 1/1/1 was a Monday. */ | ||
348 | static int | ||
349 | weekday(int year, int month, int day) | ||
350 | { | ||
351 | return (ymd_to_ord(year, month, day) + 6) % 7; | ||
352 | } | ||
353 | |||
354 | /* Ordinal of the Monday starting week 1 of the ISO year. Week 1 is the | ||
355 | * first calendar week containing a Thursday. | ||
356 | */ | ||
357 | static int | ||
358 | iso_week1_monday(int year) | ||
359 | { | ||
360 | int first_day = ymd_to_ord(year, 1, 1); /* ord of 1/1 */ | ||
361 | /* 0 if 1/1 is a Monday, 1 if a Tue, etc. */ | ||
362 | int first_weekday = (first_day + 6) % 7; | ||
363 | /* ordinal of closest Monday at or before 1/1 */ | ||
364 | int week1_monday = first_day - first_weekday; | ||
365 | |||
366 | if (first_weekday > 3) /* if 1/1 was Fri, Sat, Sun */ | ||
367 | week1_monday += 7; | ||
368 | return week1_monday; | ||
369 | } | ||
370 | |||
371 | /* --------------------------------------------------------------------------- | ||
372 | * Range checkers. | ||
373 | */ | ||
374 | |||
375 | /* Check that -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS. If so, return 0. | ||
376 | * If not, raise OverflowError and return -1. | ||
377 | */ | ||
378 | static int | ||
379 | check_delta_day_range(int days) | ||
380 | { | ||
381 | if (-MAX_DELTA_DAYS999999999 <= days && days <= MAX_DELTA_DAYS999999999) | ||
382 | return 0; | ||
383 | PyErr_Format(PyExc_OverflowError, | ||
384 | "days=%d; must have magnitude <= %d", | ||
385 | days, MAX_DELTA_DAYS999999999); | ||
386 | return -1; | ||
387 | } | ||
388 | |||
389 | /* Check that date arguments are in range. Return 0 if they are. If they | ||
390 | * aren't, raise ValueError and return -1. | ||
391 | */ | ||
392 | static int | ||
393 | check_date_args(int year, int month, int day) | ||
394 | { | ||
395 | |||
396 | if (year < MINYEAR1 || year > MAXYEAR9999) { | ||
397 | PyErr_SetString(PyExc_ValueError, | ||
398 | "year is out of range"); | ||
399 | return -1; | ||
400 | } | ||
401 | if (month < 1 || month > 12) { | ||
402 | PyErr_SetString(PyExc_ValueError, | ||
403 | "month must be in 1..12"); | ||
404 | return -1; | ||
405 | } | ||
406 | if (day < 1 || day > days_in_month(year, month)) { | ||
407 | PyErr_SetString(PyExc_ValueError, | ||
408 | "day is out of range for month"); | ||
409 | return -1; | ||
410 | } | ||
411 | return 0; | ||
412 | } | ||
413 | |||
414 | /* Check that time arguments are in range. Return 0 if they are. If they | ||
415 | * aren't, raise ValueError and return -1. | ||
416 | */ | ||
417 | static int | ||
418 | check_time_args(int h, int m, int s, int us) | ||
419 | { | ||
420 | if (h < 0 || h > 23) { | ||
421 | PyErr_SetString(PyExc_ValueError, | ||
422 | "hour must be in 0..23"); | ||
423 | return -1; | ||
424 | } | ||
425 | if (m < 0 || m > 59) { | ||
426 | PyErr_SetString(PyExc_ValueError, | ||
427 | "minute must be in 0..59"); | ||
428 | return -1; | ||
429 | } | ||
430 | if (s < 0 || s > 59) { | ||
431 | PyErr_SetString(PyExc_ValueError, | ||
432 | "second must be in 0..59"); | ||
433 | return -1; | ||
434 | } | ||
435 | if (us < 0 || us > 999999) { | ||
436 | PyErr_SetString(PyExc_ValueError, | ||
437 | "microsecond must be in 0..999999"); | ||
438 | return -1; | ||
439 | } | ||
440 | return 0; | ||
441 | } | ||
442 | |||
443 | /* --------------------------------------------------------------------------- | ||
444 | * Normalization utilities. | ||
445 | */ | ||
446 | |||
447 | /* One step of a mixed-radix conversion. A "hi" unit is equivalent to | ||
448 | * factor "lo" units. factor must be > 0. If *lo is less than 0, or | ||
449 | * at least factor, enough of *lo is converted into "hi" units so that | ||
450 | * 0 <= *lo < factor. The input values must be such that int overflow | ||
451 | * is impossible. | ||
452 | */ | ||
453 | static void | ||
454 | normalize_pair(int *hi, int *lo, int factor) | ||
455 | { | ||
456 | assert(factor > 0)(__builtin_expect(!(factor > 0), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 456, "factor > 0") : (void)0); | ||
457 | assert(lo != hi)(__builtin_expect(!(lo != hi), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 457, "lo != hi") : (void)0); | ||
458 | if (*lo < 0 || *lo >= factor) { | ||
459 | const int num_hi = divmod(*lo, factor, lo); | ||
460 | const int new_hi = *hi + num_hi; | ||
461 | assert(! SIGNED_ADD_OVERFLOWED(new_hi, *hi, num_hi))(__builtin_expect(!(! ((((new_hi) ^ (*hi)) & ((new_hi) ^ ( num_hi))) < 0)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 461, "! SIGNED_ADD_OVERFLOWED(new_hi, *hi, num_hi)") : (void )0); | ||
462 | *hi = new_hi; | ||
463 | } | ||
464 | assert(0 <= *lo && *lo < factor)(__builtin_expect(!(0 <= *lo && *lo < factor), 0 ) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 464, "0 <= *lo && *lo < factor") : (void)0); | ||
465 | } | ||
466 | |||
467 | /* Fiddle days (d), seconds (s), and microseconds (us) so that | ||
468 | * 0 <= *s < 24*3600 | ||
469 | * 0 <= *us < 1000000 | ||
470 | * The input values must be such that the internals don't overflow. | ||
471 | * The way this routine is used, we don't get close. | ||
472 | */ | ||
473 | static void | ||
474 | normalize_d_s_us(int *d, int *s, int *us) | ||
475 | { | ||
476 | if (*us < 0 || *us >= 1000000) { | ||
477 | normalize_pair(s, us, 1000000); | ||
478 | /* |s| can't be bigger than about | ||
479 | * |original s| + |original us|/1000000 now. | ||
480 | */ | ||
481 | |||
482 | } | ||
483 | if (*s < 0 || *s >= 24*3600) { | ||
484 | normalize_pair(d, s, 24*3600); | ||
485 | /* |d| can't be bigger than about | ||
486 | * |original d| + | ||
487 | * (|original s| + |original us|/1000000) / (24*3600) now. | ||
488 | */ | ||
489 | } | ||
490 | assert(0 <= *s && *s < 24*3600)(__builtin_expect(!(0 <= *s && *s < 24*3600), 0 ) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 490, "0 <= *s && *s < 24*3600") : (void)0); | ||
491 | assert(0 <= *us && *us < 1000000)(__builtin_expect(!(0 <= *us && *us < 1000000), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 491, "0 <= *us && *us < 1000000") : (void)0); | ||
492 | } | ||
493 | |||
494 | /* Fiddle years (y), months (m), and days (d) so that | ||
495 | * 1 <= *m <= 12 | ||
496 | * 1 <= *d <= days_in_month(*y, *m) | ||
497 | * The input values must be such that the internals don't overflow. | ||
498 | * The way this routine is used, we don't get close. | ||
499 | */ | ||
500 | static int | ||
501 | normalize_y_m_d(int *y, int *m, int *d) | ||
502 | { | ||
503 | int dim; /* # of days in month */ | ||
504 | |||
505 | /* In actual use, m is always the month component extracted from a | ||
506 | * date/datetime object. Therefore it is always in [1, 12] range. | ||
507 | */ | ||
508 | |||
509 | assert(1 <= *m && *m <= 12)(__builtin_expect(!(1 <= *m && *m <= 12), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 509, "1 <= *m && *m <= 12") : (void)0); | ||
510 | |||
511 | /* Now only day can be out of bounds (year may also be out of bounds | ||
512 | * for a datetime object, but we don't care about that here). | ||
513 | * If day is out of bounds, what to do is arguable, but at least the | ||
514 | * method here is principled and explainable. | ||
515 | */ | ||
516 | dim = days_in_month(*y, *m); | ||
517 | if (*d < 1 || *d > dim) { | ||
518 | /* Move day-1 days from the first of the month. First try to | ||
519 | * get off cheap if we're only one day out of range | ||
520 | * (adjustments for timezone alone can't be worse than that). | ||
521 | */ | ||
522 | if (*d == 0) { | ||
523 | --*m; | ||
524 | if (*m > 0) | ||
525 | *d = days_in_month(*y, *m); | ||
526 | else { | ||
527 | --*y; | ||
528 | *m = 12; | ||
529 | *d = 31; | ||
530 | } | ||
531 | } | ||
532 | else if (*d == dim + 1) { | ||
533 | /* move forward a day */ | ||
534 | ++*m; | ||
535 | *d = 1; | ||
536 | if (*m > 12) { | ||
537 | *m = 1; | ||
538 | ++*y; | ||
539 | } | ||
540 | } | ||
541 | else { | ||
542 | int ordinal = ymd_to_ord(*y, *m, 1) + | ||
543 | *d - 1; | ||
544 | if (ordinal < 1 || ordinal > MAXORDINAL3652059) { | ||
545 | goto error; | ||
546 | } else { | ||
547 | ord_to_ymd(ordinal, y, m, d); | ||
548 | return 0; | ||
549 | } | ||
550 | } | ||
551 | } | ||
552 | assert(*m > 0)(__builtin_expect(!(*m > 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 552, "*m > 0") : (void)0); | ||
553 | assert(*d > 0)(__builtin_expect(!(*d > 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 553, "*d > 0") : (void)0); | ||
554 | if (MINYEAR1 <= *y && *y <= MAXYEAR9999) | ||
555 | return 0; | ||
556 | error: | ||
557 | PyErr_SetString(PyExc_OverflowError, | ||
558 | "date value out of range"); | ||
559 | return -1; | ||
560 | |||
561 | } | ||
562 | |||
563 | /* Fiddle out-of-bounds months and days so that the result makes some kind | ||
564 | * of sense. The parameters are both inputs and outputs. Returns < 0 on | ||
565 | * failure, where failure means the adjusted year is out of bounds. | ||
566 | */ | ||
567 | static int | ||
568 | normalize_date(int *year, int *month, int *day) | ||
569 | { | ||
570 | return normalize_y_m_d(year, month, day); | ||
571 | } | ||
572 | |||
573 | /* Force all the datetime fields into range. The parameters are both | ||
574 | * inputs and outputs. Returns < 0 on error. | ||
575 | */ | ||
576 | static int | ||
577 | normalize_datetime(int *year, int *month, int *day, | ||
578 | int *hour, int *minute, int *second, | ||
579 | int *microsecond) | ||
580 | { | ||
581 | normalize_pair(second, microsecond, 1000000); | ||
582 | normalize_pair(minute, second, 60); | ||
583 | normalize_pair(hour, minute, 60); | ||
584 | normalize_pair(day, hour, 24); | ||
585 | return normalize_date(year, month, day); | ||
586 | } | ||
587 | |||
588 | /* --------------------------------------------------------------------------- | ||
589 | * Basic object allocation: tp_alloc implementations. These allocate | ||
590 | * Python objects of the right size and type, and do the Python object- | ||
591 | * initialization bit. If there's not enough memory, they return NULL after | ||
592 | * setting MemoryError. All data members remain uninitialized trash. | ||
593 | * | ||
594 | * We abuse the tp_alloc "nitems" argument to communicate whether a tzinfo | ||
595 | * member is needed. This is ugly, imprecise, and possibly insecure. | ||
596 | * tp_basicsize for the time and datetime types is set to the size of the | ||
597 | * struct that has room for the tzinfo member, so subclasses in Python will | ||
598 | * allocate enough space for a tzinfo member whether or not one is actually | ||
599 | * needed. That's the "ugly and imprecise" parts. The "possibly insecure" | ||
600 | * part is that PyType_GenericAlloc() (which subclasses in Python end up | ||
601 | * using) just happens today to effectively ignore the nitems argument | ||
602 | * when tp_itemsize is 0, which it is for these type objects. If that | ||
603 | * changes, perhaps the callers of tp_alloc slots in this file should | ||
604 | * be changed to force a 0 nitems argument unless the type being allocated | ||
605 | * is a base type implemented in this file (so that tp_alloc is time_alloc | ||
606 | * or datetime_alloc below, which know about the nitems abuse). | ||
607 | */ | ||
608 | |||
609 | static PyObject * | ||
610 | time_alloc(PyTypeObject *type, Py_ssize_t aware) | ||
611 | { | ||
612 | PyObject *self; | ||
613 | |||
614 | self = (PyObject *) | ||
615 | PyObject_MALLOC_PyObject_DebugMalloc(aware ? | ||
616 | sizeof(PyDateTime_Time) : | ||
617 | sizeof(_PyDateTime_BaseTime)); | ||
618 | if (self == NULL((void*)0)) | ||
619 | return (PyObject *)PyErr_NoMemory(); | ||
620 | PyObject_INIT(self, type)( (((PyObject*)(self))->ob_type) = (type), _Py_NewReference ((PyObject *)(self)), (self) ); | ||
621 | return self; | ||
622 | } | ||
623 | |||
624 | static PyObject * | ||
625 | datetime_alloc(PyTypeObject *type, Py_ssize_t aware) | ||
626 | { | ||
627 | PyObject *self; | ||
628 | |||
629 | self = (PyObject *) | ||
630 | PyObject_MALLOC_PyObject_DebugMalloc(aware ? | ||
631 | sizeof(PyDateTime_DateTime) : | ||
632 | sizeof(_PyDateTime_BaseDateTime)); | ||
633 | if (self == NULL((void*)0)) | ||
634 | return (PyObject *)PyErr_NoMemory(); | ||
635 | PyObject_INIT(self, type)( (((PyObject*)(self))->ob_type) = (type), _Py_NewReference ((PyObject *)(self)), (self) ); | ||
636 | return self; | ||
637 | } | ||
638 | |||
639 | /* --------------------------------------------------------------------------- | ||
640 | * Helpers for setting object fields. These work on pointers to the | ||
641 | * appropriate base class. | ||
642 | */ | ||
643 | |||
644 | /* For date and datetime. */ | ||
645 | static void | ||
646 | set_date_fields(PyDateTime_Date *self, int y, int m, int d) | ||
647 | { | ||
648 | self->hashcode = -1; | ||
649 | SET_YEAR(self, y)(((self)->data[0] = ((y) & 0xff00) >> 8), ((self )->data[1] = ((y) & 0x00ff))); | ||
650 | SET_MONTH(self, m)((((PyDateTime_Date*)self)->data[2]) = (m)); | ||
651 | SET_DAY(self, d)((((PyDateTime_Date*)self)->data[3]) = (d)); | ||
652 | } | ||
653 | |||
654 | /* --------------------------------------------------------------------------- | ||
655 | * Create various objects, mostly without range checking. | ||
656 | */ | ||
657 | |||
658 | /* Create a date instance with no range checking. */ | ||
659 | static PyObject * | ||
660 | new_date_ex(int year, int month, int day, PyTypeObject *type) | ||
661 | { | ||
662 | PyDateTime_Date *self; | ||
663 | |||
664 | self = (PyDateTime_Date *) (type->tp_alloc(type, 0)); | ||
665 | if (self != NULL((void*)0)) | ||
666 | set_date_fields(self, year, month, day); | ||
667 | return (PyObject *) self; | ||
668 | } | ||
669 | |||
670 | #define new_date(year, month, day)new_date_ex(year, month, day, &PyDateTime_DateType) \ | ||
671 | new_date_ex(year, month, day, &PyDateTime_DateType) | ||
672 | |||
673 | /* Create a datetime instance with no range checking. */ | ||
674 | static PyObject * | ||
675 | new_datetime_ex(int year, int month, int day, int hour, int minute, | ||
676 | int second, int usecond, PyObject *tzinfo, PyTypeObject *type) | ||
677 | { | ||
678 | PyDateTime_DateTime *self; | ||
679 | char aware = tzinfo != Py_None(&_Py_NoneStruct); | ||
680 | |||
681 | self = (PyDateTime_DateTime *) (type->tp_alloc(type, aware)); | ||
682 | if (self != NULL((void*)0)) { | ||
683 | self->hastzinfo = aware; | ||
684 | set_date_fields((PyDateTime_Date *)self, year, month, day); | ||
685 | DATE_SET_HOUR(self, hour)((((PyDateTime_DateTime*)self)->data[4]) = (hour)); | ||
686 | DATE_SET_MINUTE(self, minute)((((PyDateTime_DateTime*)self)->data[5]) = (minute)); | ||
687 | DATE_SET_SECOND(self, second)((((PyDateTime_DateTime*)self)->data[6]) = (second)); | ||
688 | DATE_SET_MICROSECOND(self, usecond)(((self)->data[7] = ((usecond) & 0xff0000) >> 16 ), ((self)->data[8] = ((usecond) & 0x00ff00) >> 8 ), ((self)->data[9] = ((usecond) & 0x0000ff))); | ||
689 | if (aware) { | ||
690 | Py_INCREF(tzinfo)( _Py_RefTotal++ , ((PyObject*)(tzinfo))->ob_refcnt++); | ||
691 | self->tzinfo = tzinfo; | ||
692 | } | ||
693 | } | ||
694 | return (PyObject *)self; | ||
695 | } | ||
696 | |||
697 | #define new_datetime(y, m, d, hh, mm, ss, us, tzinfo)new_datetime_ex(y, m, d, hh, mm, ss, us, tzinfo, &PyDateTime_DateTimeType ) \ | ||
698 | new_datetime_ex(y, m, d, hh, mm, ss, us, tzinfo, \ | ||
699 | &PyDateTime_DateTimeType) | ||
700 | |||
701 | /* Create a time instance with no range checking. */ | ||
702 | static PyObject * | ||
703 | new_time_ex(int hour, int minute, int second, int usecond, | ||
704 | PyObject *tzinfo, PyTypeObject *type) | ||
705 | { | ||
706 | PyDateTime_Time *self; | ||
707 | char aware = tzinfo != Py_None(&_Py_NoneStruct); | ||
708 | |||
709 | self = (PyDateTime_Time *) (type->tp_alloc(type, aware)); | ||
710 | if (self != NULL((void*)0)) { | ||
711 | self->hastzinfo = aware; | ||
712 | self->hashcode = -1; | ||
713 | TIME_SET_HOUR(self, hour)((((PyDateTime_Time*)self)->data[0]) = (hour)); | ||
714 | TIME_SET_MINUTE(self, minute)((((PyDateTime_Time*)self)->data[1]) = (minute)); | ||
715 | TIME_SET_SECOND(self, second)((((PyDateTime_Time*)self)->data[2]) = (second)); | ||
716 | TIME_SET_MICROSECOND(self, usecond)(((self)->data[3] = ((usecond) & 0xff0000) >> 16 ), ((self)->data[4] = ((usecond) & 0x00ff00) >> 8 ), ((self)->data[5] = ((usecond) & 0x0000ff))); | ||
717 | if (aware) { | ||
718 | Py_INCREF(tzinfo)( _Py_RefTotal++ , ((PyObject*)(tzinfo))->ob_refcnt++); | ||
719 | self->tzinfo = tzinfo; | ||
720 | } | ||
721 | } | ||
722 | return (PyObject *)self; | ||
723 | } | ||
724 | |||
725 | #define new_time(hh, mm, ss, us, tzinfo)new_time_ex(hh, mm, ss, us, tzinfo, &PyDateTime_TimeType) \ | ||
726 | new_time_ex(hh, mm, ss, us, tzinfo, &PyDateTime_TimeType) | ||
727 | |||
728 | /* Create a timedelta instance. Normalize the members iff normalize is | ||
729 | * true. Passing false is a speed optimization, if you know for sure | ||
730 | * that seconds and microseconds are already in their proper ranges. In any | ||
731 | * case, raises OverflowError and returns NULL if the normalized days is out | ||
732 | * of range). | ||
733 | */ | ||
734 | static PyObject * | ||
735 | new_delta_ex(int days, int seconds, int microseconds, int normalize, | ||
736 | PyTypeObject *type) | ||
737 | { | ||
738 | PyDateTime_Delta *self; | ||
739 | |||
740 | if (normalize) | ||
741 | normalize_d_s_us(&days, &seconds, µseconds); | ||
742 | assert(0 <= seconds && seconds < 24*3600)(__builtin_expect(!(0 <= seconds && seconds < 24 *3600), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 742, "0 <= seconds && seconds < 24*3600") : ( void)0); | ||
743 | assert(0 <= microseconds && microseconds < 1000000)(__builtin_expect(!(0 <= microseconds && microseconds < 1000000), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 743, "0 <= microseconds && microseconds < 1000000" ) : (void)0); | ||
744 | |||
745 | if (check_delta_day_range(days) < 0) | ||
746 | return NULL((void*)0); | ||
747 | |||
748 | self = (PyDateTime_Delta *) (type->tp_alloc(type, 0)); | ||
749 | if (self != NULL((void*)0)) { | ||
750 | self->hashcode = -1; | ||
751 | SET_TD_DAYS(self, days)((self)->days = (days)); | ||
752 | SET_TD_SECONDS(self, seconds)((self)->seconds = (seconds)); | ||
753 | SET_TD_MICROSECONDS(self, microseconds)((self)->microseconds = (microseconds)); | ||
754 | } | ||
755 | return (PyObject *) self; | ||
756 | } | ||
757 | |||
758 | #define new_delta(d, s, us, normalize)new_delta_ex(d, s, us, normalize, &PyDateTime_DeltaType) \ | ||
759 | new_delta_ex(d, s, us, normalize, &PyDateTime_DeltaType) | ||
760 | |||
761 | |||
762 | typedef struct | ||
763 | { | ||
764 | PyObject_HEADPyObject ob_base; | ||
765 | PyObject *offset; | ||
766 | PyObject *name; | ||
767 | } PyDateTime_TimeZone; | ||
768 | |||
769 | /* The interned UTC timezone instance */ | ||
770 | static PyObject *PyDateTime_TimeZone_UTC; | ||
771 | |||
772 | /* Create new timezone instance checking offset range. This | ||
773 | function does not check the name argument. Caller must assure | ||
774 | that offset is a timedelta instance and name is either NULL | ||
775 | or a unicode object. */ | ||
776 | static PyObject * | ||
777 | create_timezone(PyObject *offset, PyObject *name) | ||
778 | { | ||
779 | PyDateTime_TimeZone *self; | ||
780 | PyTypeObject *type = &PyDateTime_TimeZoneType; | ||
781 | |||
782 | assert(offset != NULL)(__builtin_expect(!(offset != ((void*)0)), 0) ? __assert_rtn( __func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 782, "offset != NULL") : (void)0); | ||
783 | assert(PyDelta_Check(offset))(__builtin_expect(!(((((PyObject*)(offset))->ob_type) == ( &PyDateTime_DeltaType) || PyType_IsSubtype((((PyObject*)( offset))->ob_type), (&PyDateTime_DeltaType)))), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 783, "PyDelta_Check(offset)") : (void)0); | ||
784 | assert(name == NULL || PyUnicode_Check(name))(__builtin_expect(!(name == ((void*)0) || ((((((PyObject*)(name ))->ob_type))->tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 784, "name == NULL || PyUnicode_Check(name)") : (void)0); | ||
785 | |||
786 | self = (PyDateTime_TimeZone *)(type->tp_alloc(type, 0)); | ||
787 | if (self == NULL((void*)0)) { | ||
788 | return NULL((void*)0); | ||
789 | } | ||
790 | Py_INCREF(offset)( _Py_RefTotal++ , ((PyObject*)(offset))->ob_refcnt++); | ||
791 | self->offset = offset; | ||
792 | Py_XINCREF(name)do { if ((name) == ((void*)0)) ; else ( _Py_RefTotal++ , ((PyObject *)(name))->ob_refcnt++); } while (0); | ||
793 | self->name = name; | ||
794 | return (PyObject *)self; | ||
795 | } | ||
796 | |||
797 | static int delta_bool(PyDateTime_Delta *self); | ||
798 | |||
799 | static PyObject * | ||
800 | new_timezone(PyObject *offset, PyObject *name) | ||
801 | { | ||
802 | assert(offset != NULL)(__builtin_expect(!(offset != ((void*)0)), 0) ? __assert_rtn( __func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 802, "offset != NULL") : (void)0); | ||
803 | assert(PyDelta_Check(offset))(__builtin_expect(!(((((PyObject*)(offset))->ob_type) == ( &PyDateTime_DeltaType) || PyType_IsSubtype((((PyObject*)( offset))->ob_type), (&PyDateTime_DeltaType)))), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 803, "PyDelta_Check(offset)") : (void)0); | ||
804 | assert(name == NULL || PyUnicode_Check(name))(__builtin_expect(!(name == ((void*)0) || ((((((PyObject*)(name ))->ob_type))->tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 804, "name == NULL || PyUnicode_Check(name)") : (void)0); | ||
805 | |||
806 | if (name == NULL((void*)0) && delta_bool((PyDateTime_Delta *)offset) == 0) { | ||
807 | Py_INCREF(PyDateTime_TimeZone_UTC)( _Py_RefTotal++ , ((PyObject*)(PyDateTime_TimeZone_UTC))-> ob_refcnt++); | ||
808 | return PyDateTime_TimeZone_UTC; | ||
809 | } | ||
810 | if (GET_TD_MICROSECONDS(offset)(((PyDateTime_Delta *)(offset))->microseconds) != 0 || GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds) % 60 != 0) { | ||
811 | PyErr_Format(PyExc_ValueError, "offset must be a timedelta" | ||
812 | " representing a whole number of minutes"); | ||
813 | return NULL((void*)0); | ||
814 | } | ||
815 | if ((GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) == -1 && GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds) == 0) || | ||
816 | GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) < -1 || GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) >= 1) { | ||
817 | PyErr_Format(PyExc_ValueError, "offset must be a timedelta" | ||
818 | " strictly between -timedelta(hours=24) and" | ||
819 | " timedelta(hours=24)."); | ||
820 | return NULL((void*)0); | ||
821 | } | ||
822 | |||
823 | return create_timezone(offset, name); | ||
824 | } | ||
825 | |||
826 | /* --------------------------------------------------------------------------- | ||
827 | * tzinfo helpers. | ||
828 | */ | ||
829 | |||
830 | /* Ensure that p is None or of a tzinfo subclass. Return 0 if OK; if not | ||
831 | * raise TypeError and return -1. | ||
832 | */ | ||
833 | static int | ||
834 | check_tzinfo_subclass(PyObject *p) | ||
835 | { | ||
836 | if (p == Py_None(&_Py_NoneStruct) || PyTZInfo_Check(p)((((PyObject*)(p))->ob_type) == (&PyDateTime_TZInfoType ) || PyType_IsSubtype((((PyObject*)(p))->ob_type), (&PyDateTime_TZInfoType )))) | ||
837 | return 0; | ||
838 | PyErr_Format(PyExc_TypeError, | ||
839 | "tzinfo argument must be None or of a tzinfo subclass, " | ||
840 | "not type '%s'", | ||
841 | Py_TYPE(p)(((PyObject*)(p))->ob_type)->tp_name); | ||
842 | return -1; | ||
843 | } | ||
844 | |||
845 | /* If self has a tzinfo member, return a BORROWED reference to it. Else | ||
846 | * return NULL, which is NOT AN ERROR. There are no error returns here, | ||
847 | * and the caller must not decref the result. | ||
848 | */ | ||
849 | static PyObject * | ||
850 | get_tzinfo_member(PyObject *self) | ||
851 | { | ||
852 | PyObject *tzinfo = NULL((void*)0); | ||
853 | |||
854 | if (PyDateTime_Check(self)((((PyObject*)(self))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(self))->ob_type), (& PyDateTime_DateTimeType))) && HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) | ||
855 | tzinfo = ((PyDateTime_DateTime *)self)->tzinfo; | ||
856 | else if (PyTime_Check(self)((((PyObject*)(self))->ob_type) == (&PyDateTime_TimeType ) || PyType_IsSubtype((((PyObject*)(self))->ob_type), (& PyDateTime_TimeType))) && HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) | ||
857 | tzinfo = ((PyDateTime_Time *)self)->tzinfo; | ||
858 | |||
859 | return tzinfo; | ||
860 | } | ||
861 | |||
862 | /* Call getattr(tzinfo, name)(tzinfoarg), and check the result. tzinfo must | ||
863 | * be an instance of the tzinfo class. If the method returns None, this | ||
864 | * returns None. If the method doesn't return None or timedelta, TypeError is | ||
865 | * raised and this returns NULL. If it returns a timedelta and the value is | ||
866 | * out of range or isn't a whole number of minutes, ValueError is raised and | ||
867 | * this returns NULL. Else result is returned. | ||
868 | */ | ||
869 | static PyObject * | ||
870 | call_tzinfo_method(PyObject *tzinfo, char *name, PyObject *tzinfoarg) | ||
871 | { | ||
872 | PyObject *offset; | ||
873 | |||
874 | assert(tzinfo != NULL)(__builtin_expect(!(tzinfo != ((void*)0)), 0) ? __assert_rtn( __func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 874, "tzinfo != NULL") : (void)0); | ||
875 | assert(PyTZInfo_Check(tzinfo) || tzinfo == Py_None)(__builtin_expect(!(((((PyObject*)(tzinfo))->ob_type) == ( &PyDateTime_TZInfoType) || PyType_IsSubtype((((PyObject*) (tzinfo))->ob_type), (&PyDateTime_TZInfoType))) || tzinfo == (&_Py_NoneStruct)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 875, "PyTZInfo_Check(tzinfo) || tzinfo == Py_None") : (void )0); | ||
876 | assert(tzinfoarg != NULL)(__builtin_expect(!(tzinfoarg != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 876, "tzinfoarg != NULL") : (void)0); | ||
877 | |||
878 | if (tzinfo == Py_None(&_Py_NoneStruct)) | ||
879 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct); | ||
880 | offset = PyObject_CallMethod(tzinfo, name, "O", tzinfoarg); | ||
881 | if (offset == Py_None(&_Py_NoneStruct) || offset == NULL((void*)0)) | ||
882 | return offset; | ||
883 | if (PyDelta_Check(offset)((((PyObject*)(offset))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(offset))->ob_type), (& PyDateTime_DeltaType)))) { | ||
884 | if (GET_TD_MICROSECONDS(offset)(((PyDateTime_Delta *)(offset))->microseconds) != 0 || GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds) % 60 != 0) { | ||
885 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 885, (PyObject *)(offset)); } else _Py_Dealloc((PyObject *) (offset)); } while (0); | ||
886 | PyErr_Format(PyExc_ValueError, "offset must be a timedelta" | ||
887 | " representing a whole number of minutes"); | ||
888 | return NULL((void*)0); | ||
889 | } | ||
890 | if ((GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) == -1 && GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds) == 0) || | ||
891 | GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) < -1 || GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) >= 1) { | ||
892 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 892, (PyObject *)(offset)); } else _Py_Dealloc((PyObject *) (offset)); } while (0); | ||
893 | PyErr_Format(PyExc_ValueError, "offset must be a timedelta" | ||
894 | " strictly between -timedelta(hours=24) and" | ||
895 | " timedelta(hours=24)."); | ||
896 | return NULL((void*)0); | ||
897 | } | ||
898 | } | ||
899 | else { | ||
900 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 900, (PyObject *)(offset)); } else _Py_Dealloc((PyObject *) (offset)); } while (0); | ||
901 | PyErr_Format(PyExc_TypeError, | ||
902 | "tzinfo.%s() must return None or " | ||
903 | "timedelta, not '%.200s'", | ||
904 | name, Py_TYPE(offset)(((PyObject*)(offset))->ob_type)->tp_name); | ||
905 | return NULL((void*)0); | ||
906 | } | ||
907 | |||
908 | return offset; | ||
909 | } | ||
910 | |||
911 | /* Call tzinfo.utcoffset(tzinfoarg), and extract an integer from the | ||
912 | * result. tzinfo must be an instance of the tzinfo class. If utcoffset() | ||
913 | * returns None, call_utcoffset returns 0 and sets *none to 1. If uctoffset() | ||
914 | * doesn't return None or timedelta, TypeError is raised and this returns -1. | ||
915 | * If utcoffset() returns an invalid timedelta (out of range, or not a whole | ||
916 | * # of minutes), ValueError is raised and this returns -1. Else *none is | ||
917 | * set to 0 and the offset is returned (as int # of minutes east of UTC). | ||
918 | */ | ||
919 | static PyObject * | ||
920 | call_utcoffset(PyObject *tzinfo, PyObject *tzinfoarg) | ||
921 | { | ||
922 | return call_tzinfo_method(tzinfo, "utcoffset", tzinfoarg); | ||
923 | } | ||
924 | |||
925 | /* Call tzinfo.dst(tzinfoarg), and extract an integer from the | ||
926 | * result. tzinfo must be an instance of the tzinfo class. If dst() | ||
927 | * returns None, call_dst returns 0 and sets *none to 1. If dst() | ||
928 | & doesn't return None or timedelta, TypeError is raised and this | ||
929 | * returns -1. If dst() returns an invalid timedelta for a UTC offset, | ||
930 | * ValueError is raised and this returns -1. Else *none is set to 0 and | ||
931 | * the offset is returned (as an int # of minutes east of UTC). | ||
932 | */ | ||
933 | static PyObject * | ||
934 | call_dst(PyObject *tzinfo, PyObject *tzinfoarg) | ||
935 | { | ||
936 | return call_tzinfo_method(tzinfo, "dst", tzinfoarg); | ||
937 | } | ||
938 | |||
939 | /* Call tzinfo.tzname(tzinfoarg), and return the result. tzinfo must be | ||
940 | * an instance of the tzinfo class or None. If tzinfo isn't None, and | ||
941 | * tzname() doesn't return None or a string, TypeError is raised and this | ||
942 | * returns NULL. If the result is a string, we ensure it is a Unicode | ||
943 | * string. | ||
944 | */ | ||
945 | static PyObject * | ||
946 | call_tzname(PyObject *tzinfo, PyObject *tzinfoarg) | ||
947 | { | ||
948 | PyObject *result; | ||
949 | |||
950 | assert(tzinfo != NULL)(__builtin_expect(!(tzinfo != ((void*)0)), 0) ? __assert_rtn( __func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 950, "tzinfo != NULL") : (void)0); | ||
951 | assert(check_tzinfo_subclass(tzinfo) >= 0)(__builtin_expect(!(check_tzinfo_subclass(tzinfo) >= 0), 0 ) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 951, "check_tzinfo_subclass(tzinfo) >= 0") : (void)0); | ||
952 | assert(tzinfoarg != NULL)(__builtin_expect(!(tzinfoarg != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 952, "tzinfoarg != NULL") : (void)0); | ||
953 | |||
954 | if (tzinfo == Py_None(&_Py_NoneStruct)) | ||
955 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct); | ||
956 | |||
957 | result = PyObject_CallMethod(tzinfo, "tzname", "O", tzinfoarg); | ||
958 | |||
959 | if (result == NULL((void*)0) || result == Py_None(&_Py_NoneStruct)) | ||
960 | return result; | ||
961 | |||
962 | if (!PyUnicode_Check(result)((((((PyObject*)(result))->ob_type))->tp_flags & (( 1L<<28))) != 0)) { | ||
963 | PyErr_Format(PyExc_TypeError, "tzinfo.tzname() must " | ||
964 | "return None or a string, not '%s'", | ||
965 | Py_TYPE(result)(((PyObject*)(result))->ob_type)->tp_name); | ||
966 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 966, (PyObject *)(result)); } else _Py_Dealloc((PyObject *) (result)); } while (0); | ||
967 | result = NULL((void*)0); | ||
968 | } | ||
969 | |||
970 | return result; | ||
971 | } | ||
972 | |||
973 | /* repr is like "someclass(arg1, arg2)". If tzinfo isn't None, | ||
974 | * stuff | ||
975 | * ", tzinfo=" + repr(tzinfo) | ||
976 | * before the closing ")". | ||
977 | */ | ||
978 | static PyObject * | ||
979 | append_keyword_tzinfo(PyObject *repr, PyObject *tzinfo) | ||
980 | { | ||
981 | PyObject *temp; | ||
982 | |||
983 | assert(PyUnicode_Check(repr))(__builtin_expect(!(((((((PyObject*)(repr))->ob_type))-> tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 983, "PyUnicode_Check(repr)") : (void)0); | ||
984 | assert(tzinfo)(__builtin_expect(!(tzinfo), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 984, "tzinfo") : (void)0); | ||
985 | if (tzinfo == Py_None(&_Py_NoneStruct)) | ||
986 | return repr; | ||
987 | /* Get rid of the trailing ')'. */ | ||
988 | assert(PyUnicode_AS_UNICODE(repr)[PyUnicode_GET_SIZE(repr)-1] == ')')(__builtin_expect(!(((__builtin_expect(!(((((((PyObject*)(repr ))->ob_type))->tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 988, "PyUnicode_Check(repr)") : (void)0),(((PyUnicodeObject *)(repr))->str))[((__builtin_expect(!(((((((PyObject*)(repr ))->ob_type))->tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 988, "PyUnicode_Check(repr)") : (void)0),(((PyUnicodeObject *)(repr))->length))-1] == ')'), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 988, "PyUnicode_AS_UNICODE(repr)[PyUnicode_GET_SIZE(repr)-1] == ')'" ) : (void)0); | ||
989 | temp = PyUnicode_FromUnicodePyUnicodeUCS2_FromUnicode(PyUnicode_AS_UNICODE(repr)((__builtin_expect(!(((((((PyObject*)(repr))->ob_type))-> tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 989, "PyUnicode_Check(repr)") : (void)0),(((PyUnicodeObject *)(repr))->str)), | ||
990 | PyUnicode_GET_SIZE(repr)((__builtin_expect(!(((((((PyObject*)(repr))->ob_type))-> tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 990, "PyUnicode_Check(repr)") : (void)0),(((PyUnicodeObject *)(repr))->length)) - 1); | ||
991 | Py_DECREF(repr)do { if (_Py_RefTotal-- , --((PyObject*)(repr))->ob_refcnt != 0) { if (((PyObject*)repr)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 991, (PyObject *)(repr)); } else _Py_Dealloc((PyObject *)(repr )); } while (0); | ||
992 | if (temp == NULL((void*)0)) | ||
993 | return NULL((void*)0); | ||
994 | repr = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%U, tzinfo=%R)", temp, tzinfo); | ||
995 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 995, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)(temp )); } while (0); | ||
996 | return repr; | ||
997 | } | ||
998 | |||
999 | /* --------------------------------------------------------------------------- | ||
1000 | * String format helpers. | ||
1001 | */ | ||
1002 | |||
1003 | static PyObject * | ||
1004 | format_ctime(PyDateTime_Date *date, int hours, int minutes, int seconds) | ||
1005 | { | ||
1006 | static const char *DayNames[] = { | ||
1007 | "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" | ||
1008 | }; | ||
1009 | static const char *MonthNames[] = { | ||
1010 | "Jan", "Feb", "Mar", "Apr", "May", "Jun", | ||
1011 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" | ||
1012 | }; | ||
1013 | |||
1014 | int wday = weekday(GET_YEAR(date)((((PyDateTime_Date*)date)->data[0] << 8) | ((PyDateTime_Date *)date)->data[1]), GET_MONTH(date)(((PyDateTime_Date*)date)->data[2]), GET_DAY(date)(((PyDateTime_Date*)date)->data[3])); | ||
1015 | |||
1016 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s %s %2d %02d:%02d:%02d %04d", | ||
1017 | DayNames[wday], MonthNames[GET_MONTH(date)(((PyDateTime_Date*)date)->data[2])-1], | ||
1018 | GET_DAY(date)(((PyDateTime_Date*)date)->data[3]), hours, minutes, seconds, | ||
1019 | GET_YEAR(date)((((PyDateTime_Date*)date)->data[0] << 8) | ((PyDateTime_Date *)date)->data[1])); | ||
1020 | } | ||
1021 | |||
1022 | static PyObject *delta_negative(PyDateTime_Delta *self); | ||
1023 | |||
1024 | /* Add an hours & minutes UTC offset string to buf. buf has no more than | ||
1025 | * buflen bytes remaining. The UTC offset is gotten by calling | ||
1026 | * tzinfo.uctoffset(tzinfoarg). If that returns None, \0 is stored into | ||
1027 | * *buf, and that's all. Else the returned value is checked for sanity (an | ||
1028 | * integer in range), and if that's OK it's converted to an hours & minutes | ||
1029 | * string of the form | ||
1030 | * sign HH sep MM | ||
1031 | * Returns 0 if everything is OK. If the return value from utcoffset() is | ||
1032 | * bogus, an appropriate exception is set and -1 is returned. | ||
1033 | */ | ||
1034 | static int | ||
1035 | format_utcoffset(char *buf, size_t buflen, const char *sep, | ||
1036 | PyObject *tzinfo, PyObject *tzinfoarg) | ||
1037 | { | ||
1038 | PyObject *offset; | ||
1039 | int hours, minutes, seconds; | ||
1040 | char sign; | ||
1041 | |||
1042 | assert(buflen >= 1)(__builtin_expect(!(buflen >= 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1042, "buflen >= 1") : (void)0); | ||
1043 | |||
1044 | offset = call_utcoffset(tzinfo, tzinfoarg); | ||
1045 | if (offset == NULL((void*)0)) | ||
1046 | return -1; | ||
1047 | if (offset == Py_None(&_Py_NoneStruct)) { | ||
1048 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1048, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
1049 | *buf = '\0'; | ||
1050 | return 0; | ||
1051 | } | ||
1052 | /* Offset is normalized, so it is negative if days < 0 */ | ||
1053 | if (GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days) < 0) { | ||
1054 | PyObject *temp = offset; | ||
1055 | sign = '-'; | ||
1056 | offset = delta_negative((PyDateTime_Delta *)offset); | ||
1057 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1057, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1058 | if (offset == NULL((void*)0)) | ||
1059 | return -1; | ||
1060 | } | ||
1061 | else { | ||
1062 | sign = '+'; | ||
1063 | } | ||
1064 | /* Offset is not negative here. */ | ||
1065 | seconds = GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds); | ||
1066 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1066, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
1067 | minutes = divmod(seconds, 60, &seconds); | ||
1068 | hours = divmod(minutes, 60, &minutes); | ||
1069 | assert(seconds == 0)(__builtin_expect(!(seconds == 0), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1069, "seconds == 0") : (void)0); | ||
1070 | /* XXX ignore sub-minute data, curently not allowed. */ | ||
1071 | PyOS_snprintf(buf, buflen, "%c%02d%s%02d", sign, hours, sep, minutes); | ||
1072 | |||
1073 | return 0; | ||
1074 | } | ||
1075 | |||
1076 | static PyObject * | ||
1077 | make_Zreplacement(PyObject *object, PyObject *tzinfoarg) | ||
1078 | { | ||
1079 | PyObject *temp; | ||
1080 | PyObject *tzinfo = get_tzinfo_member(object); | ||
1081 | PyObject *Zreplacement = PyUnicode_FromStringAndSizePyUnicodeUCS2_FromStringAndSize(NULL((void*)0), 0); | ||
1082 | if (Zreplacement == NULL((void*)0)) | ||
1083 | return NULL((void*)0); | ||
1084 | if (tzinfo == Py_None(&_Py_NoneStruct) || tzinfo == NULL((void*)0)) | ||
1085 | return Zreplacement; | ||
1086 | |||
1087 | assert(tzinfoarg != NULL)(__builtin_expect(!(tzinfoarg != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1087, "tzinfoarg != NULL") : (void)0); | ||
1088 | temp = call_tzname(tzinfo, tzinfoarg); | ||
1089 | if (temp == NULL((void*)0)) | ||
1090 | goto Error; | ||
1091 | if (temp == Py_None(&_Py_NoneStruct)) { | ||
1092 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1092, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1093 | return Zreplacement; | ||
1094 | } | ||
1095 | |||
1096 | assert(PyUnicode_Check(temp))(__builtin_expect(!(((((((PyObject*)(temp))->ob_type))-> tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1096, "PyUnicode_Check(temp)") : (void)0); | ||
1097 | /* Since the tzname is getting stuffed into the | ||
1098 | * format, we have to double any % signs so that | ||
1099 | * strftime doesn't treat them as format codes. | ||
1100 | */ | ||
1101 | Py_DECREF(Zreplacement)do { if (_Py_RefTotal-- , --((PyObject*)(Zreplacement))->ob_refcnt != 0) { if (((PyObject*)Zreplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1101, (PyObject *)(Zreplacement)); } else _Py_Dealloc((PyObject *)(Zreplacement)); } while (0); | ||
1102 | Zreplacement = PyObject_CallMethod(temp, "replace", "ss", "%", "%%"); | ||
1103 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1103, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1104 | if (Zreplacement == NULL((void*)0)) | ||
1105 | return NULL((void*)0); | ||
1106 | if (!PyUnicode_Check(Zreplacement)((((((PyObject*)(Zreplacement))->ob_type))->tp_flags & ((1L<<28))) != 0)) { | ||
1107 | PyErr_SetString(PyExc_TypeError, | ||
1108 | "tzname.replace() did not return a string"); | ||
1109 | goto Error; | ||
1110 | } | ||
1111 | return Zreplacement; | ||
1112 | |||
1113 | Error: | ||
1114 | Py_DECREF(Zreplacement)do { if (_Py_RefTotal-- , --((PyObject*)(Zreplacement))->ob_refcnt != 0) { if (((PyObject*)Zreplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1114, (PyObject *)(Zreplacement)); } else _Py_Dealloc((PyObject *)(Zreplacement)); } while (0); | ||
1115 | return NULL((void*)0); | ||
1116 | } | ||
1117 | |||
1118 | static PyObject * | ||
1119 | make_freplacement(PyObject *object) | ||
1120 | { | ||
1121 | char freplacement[64]; | ||
1122 | if (PyTime_Check(object)((((PyObject*)(object))->ob_type) == (&PyDateTime_TimeType ) || PyType_IsSubtype((((PyObject*)(object))->ob_type), (& PyDateTime_TimeType)))) | ||
1123 | sprintf(freplacement, "%06d", TIME_GET_MICROSECOND(object))__builtin___sprintf_chk (freplacement, 0, __builtin_object_size (freplacement, 2 > 1), "%06d", ((((PyDateTime_Time*)object )->data[3] << 16) | (((PyDateTime_Time*)object)-> data[4] << 8) | ((PyDateTime_Time*)object)->data[5]) ); | ||
1124 | else if (PyDateTime_Check(object)((((PyObject*)(object))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(object))->ob_type), (& PyDateTime_DateTimeType)))) | ||
1125 | sprintf(freplacement, "%06d", DATE_GET_MICROSECOND(object))__builtin___sprintf_chk (freplacement, 0, __builtin_object_size (freplacement, 2 > 1), "%06d", ((((PyDateTime_DateTime*)object )->data[7] << 16) | (((PyDateTime_DateTime*)object)-> data[8] << 8) | ((PyDateTime_DateTime*)object)->data [9])); | ||
1126 | else | ||
1127 | sprintf(freplacement, "%06d", 0)__builtin___sprintf_chk (freplacement, 0, __builtin_object_size (freplacement, 2 > 1), "%06d", 0); | ||
1128 | |||
1129 | return PyBytes_FromStringAndSize(freplacement, strlen(freplacement)); | ||
1130 | } | ||
1131 | |||
1132 | /* I sure don't want to reproduce the strftime code from the time module, | ||
1133 | * so this imports the module and calls it. All the hair is due to | ||
1134 | * giving special meanings to the %z, %Z and %f format codes via a | ||
1135 | * preprocessing step on the format string. | ||
1136 | * tzinfoarg is the argument to pass to the object's tzinfo method, if | ||
1137 | * needed. | ||
1138 | */ | ||
1139 | static PyObject * | ||
1140 | wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple, | ||
1141 | PyObject *tzinfoarg) | ||
1142 | { | ||
1143 | PyObject *result = NULL((void*)0); /* guilty until proved innocent */ | ||
1144 | |||
1145 | PyObject *zreplacement = NULL((void*)0); /* py string, replacement for %z */ | ||
1146 | PyObject *Zreplacement = NULL((void*)0); /* py string, replacement for %Z */ | ||
1147 | PyObject *freplacement = NULL((void*)0); /* py string, replacement for %f */ | ||
1148 | |||
1149 | const char *pin; /* pointer to next char in input format */ | ||
1150 | Py_ssize_t flen; /* length of input format */ | ||
1151 | char ch; /* next char in input format */ | ||
1152 | |||
1153 | PyObject *newfmt = NULL((void*)0); /* py string, the output format */ | ||
1154 | char *pnew; /* pointer to available byte in output format */ | ||
1155 | size_t totalnew; /* number bytes total in output format buffer, | ||
1156 | exclusive of trailing \0 */ | ||
1157 | size_t usednew; /* number bytes used so far in output format buffer */ | ||
1158 | |||
1159 | const char *ptoappend; /* ptr to string to append to output buffer */ | ||
1160 | Py_ssize_t ntoappend; /* # of bytes to append to output buffer */ | ||
1161 | |||
1162 | assert(object && format && timetuple)(__builtin_expect(!(object && format && timetuple ), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1162, "object && format && timetuple") : (void )0); | ||
1163 | assert(PyUnicode_Check(format))(__builtin_expect(!(((((((PyObject*)(format))->ob_type))-> tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1163, "PyUnicode_Check(format)") : (void)0); | ||
1164 | /* Convert the input format to a C string and size */ | ||
1165 | pin = _PyUnicode_AsStringAndSize(format, &flen); | ||
1166 | if (!pin) | ||
1167 | return NULL((void*)0); | ||
1168 | |||
1169 | /* Give up if the year is before 1000. | ||
1170 | * Python strftime() plays games with the year, and different | ||
1171 | * games depending on whether envar PYTHON2K is set. This makes | ||
1172 | * years before 1000 a nightmare, even if the platform strftime | ||
1173 | * supports them (and not all do). | ||
1174 | * We could get a lot farther here by avoiding Python's strftime | ||
1175 | * wrapper and calling the C strftime() directly, but that isn't | ||
1176 | * an option in the Python implementation of this module. | ||
1177 | */ | ||
1178 | { | ||
1179 | long year; | ||
1180 | PyObject *pyyear = PySequence_GetItem(timetuple, 0); | ||
1181 | if (pyyear == NULL((void*)0)) return NULL((void*)0); | ||
1182 | assert(PyLong_Check(pyyear))(__builtin_expect(!(((((((PyObject*)(pyyear))->ob_type))-> tp_flags & ((1L<<24))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1182, "PyLong_Check(pyyear)") : (void)0); | ||
1183 | year = PyLong_AsLong(pyyear); | ||
1184 | Py_DECREF(pyyear)do { if (_Py_RefTotal-- , --((PyObject*)(pyyear))->ob_refcnt != 0) { if (((PyObject*)pyyear)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1184, (PyObject *)(pyyear)); } else _Py_Dealloc((PyObject * )(pyyear)); } while (0); | ||
1185 | if (year < 1000) { | ||
1186 | PyErr_Format(PyExc_ValueError, "year=%ld is before " | ||
1187 | "1000; the datetime strftime() " | ||
1188 | "methods require year >= 1000", | ||
1189 | year); | ||
1190 | return NULL((void*)0); | ||
1191 | } | ||
1192 | } | ||
1193 | |||
1194 | /* Scan the input format, looking for %z/%Z/%f escapes, building | ||
1195 | * a new format. Since computing the replacements for those codes | ||
1196 | * is expensive, don't unless they're actually used. | ||
1197 | */ | ||
1198 | if (flen > INT_MAX2147483647 - 1) { | ||
1199 | PyErr_NoMemory(); | ||
1200 | goto Done; | ||
1201 | } | ||
1202 | |||
1203 | totalnew = flen + 1; /* realistic if no %z/%Z */ | ||
1204 | newfmt = PyBytes_FromStringAndSize(NULL((void*)0), totalnew); | ||
1205 | if (newfmt == NULL((void*)0)) goto Done; | ||
1206 | pnew = PyBytes_AsString(newfmt); | ||
1207 | usednew = 0; | ||
1208 | |||
1209 | while ((ch = *pin++) != '\0') { | ||
1210 | if (ch != '%') { | ||
1211 | ptoappend = pin - 1; | ||
1212 | ntoappend = 1; | ||
1213 | } | ||
1214 | else if ((ch = *pin++) == '\0') { | ||
1215 | /* There's a lone trailing %; doesn't make sense. */ | ||
1216 | PyErr_SetString(PyExc_ValueError, "strftime format " | ||
1217 | "ends with raw %"); | ||
1218 | goto Done; | ||
1219 | } | ||
1220 | /* A % has been seen and ch is the character after it. */ | ||
1221 | else if (ch == 'z') { | ||
1222 | if (zreplacement == NULL((void*)0)) { | ||
1223 | /* format utcoffset */ | ||
1224 | char buf[100]; | ||
1225 | PyObject *tzinfo = get_tzinfo_member(object); | ||
1226 | zreplacement = PyBytes_FromStringAndSize("", 0); | ||
1227 | if (zreplacement == NULL((void*)0)) goto Done; | ||
1228 | if (tzinfo != Py_None(&_Py_NoneStruct) && tzinfo != NULL((void*)0)) { | ||
1229 | assert(tzinfoarg != NULL)(__builtin_expect(!(tzinfoarg != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1229, "tzinfoarg != NULL") : (void)0); | ||
1230 | if (format_utcoffset(buf, | ||
1231 | sizeof(buf), | ||
1232 | "", | ||
1233 | tzinfo, | ||
1234 | tzinfoarg) < 0) | ||
1235 | goto Done; | ||
1236 | Py_DECREF(zreplacement)do { if (_Py_RefTotal-- , --((PyObject*)(zreplacement))->ob_refcnt != 0) { if (((PyObject*)zreplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1236, (PyObject *)(zreplacement)); } else _Py_Dealloc((PyObject *)(zreplacement)); } while (0); | ||
1237 | zreplacement = | ||
1238 | PyBytes_FromStringAndSize(buf, | ||
1239 | strlen(buf)); | ||
1240 | if (zreplacement == NULL((void*)0)) | ||
1241 | goto Done; | ||
1242 | } | ||
1243 | } | ||
1244 | assert(zreplacement != NULL)(__builtin_expect(!(zreplacement != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1244, "zreplacement != NULL") : (void)0); | ||
1245 | ptoappend = PyBytes_AS_STRING(zreplacement)((__builtin_expect(!(((((((PyObject*)(zreplacement))->ob_type ))->tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1245, "PyBytes_Check(zreplacement)") : (void)0), (((PyBytesObject *)(zreplacement))->ob_sval)); | ||
1246 | ntoappend = PyBytes_GET_SIZE(zreplacement)((__builtin_expect(!(((((((PyObject*)(zreplacement))->ob_type ))->tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1246, "PyBytes_Check(zreplacement)") : (void)0),(((PyVarObject *)(zreplacement))->ob_size)); | ||
1247 | } | ||
1248 | else if (ch == 'Z') { | ||
1249 | /* format tzname */ | ||
1250 | if (Zreplacement == NULL((void*)0)) { | ||
1251 | Zreplacement = make_Zreplacement(object, | ||
1252 | tzinfoarg); | ||
1253 | if (Zreplacement == NULL((void*)0)) | ||
1254 | goto Done; | ||
1255 | } | ||
1256 | assert(Zreplacement != NULL)(__builtin_expect(!(Zreplacement != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1256, "Zreplacement != NULL") : (void)0); | ||
1257 | assert(PyUnicode_Check(Zreplacement))(__builtin_expect(!(((((((PyObject*)(Zreplacement))->ob_type ))->tp_flags & ((1L<<28))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1257, "PyUnicode_Check(Zreplacement)") : (void)0); | ||
1258 | ptoappend = _PyUnicode_AsStringAndSize(Zreplacement, | ||
1259 | &ntoappend); | ||
1260 | if (ptoappend == NULL((void*)0)) | ||
1261 | goto Done; | ||
1262 | } | ||
1263 | else if (ch == 'f') { | ||
1264 | /* format microseconds */ | ||
1265 | if (freplacement == NULL((void*)0)) { | ||
1266 | freplacement = make_freplacement(object); | ||
1267 | if (freplacement == NULL((void*)0)) | ||
1268 | goto Done; | ||
1269 | } | ||
1270 | assert(freplacement != NULL)(__builtin_expect(!(freplacement != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1270, "freplacement != NULL") : (void)0); | ||
1271 | assert(PyBytes_Check(freplacement))(__builtin_expect(!(((((((PyObject*)(freplacement))->ob_type ))->tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1271, "PyBytes_Check(freplacement)") : (void)0); | ||
1272 | ptoappend = PyBytes_AS_STRING(freplacement)((__builtin_expect(!(((((((PyObject*)(freplacement))->ob_type ))->tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1272, "PyBytes_Check(freplacement)") : (void)0), (((PyBytesObject *)(freplacement))->ob_sval)); | ||
1273 | ntoappend = PyBytes_GET_SIZE(freplacement)((__builtin_expect(!(((((((PyObject*)(freplacement))->ob_type ))->tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1273, "PyBytes_Check(freplacement)") : (void)0),(((PyVarObject *)(freplacement))->ob_size)); | ||
1274 | } | ||
1275 | else { | ||
1276 | /* percent followed by neither z nor Z */ | ||
1277 | ptoappend = pin - 2; | ||
1278 | ntoappend = 2; | ||
1279 | } | ||
1280 | |||
1281 | /* Append the ntoappend chars starting at ptoappend to | ||
1282 | * the new format. | ||
1283 | */ | ||
1284 | if (ntoappend == 0) | ||
1285 | continue; | ||
1286 | assert(ptoappend != NULL)(__builtin_expect(!(ptoappend != ((void*)0)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1286, "ptoappend != NULL") : (void)0); | ||
1287 | assert(ntoappend > 0)(__builtin_expect(!(ntoappend > 0), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1287, "ntoappend > 0") : (void)0); | ||
1288 | while (usednew + ntoappend > totalnew) { | ||
1289 | size_t bigger = totalnew << 1; | ||
1290 | if ((bigger >> 1) != totalnew) { /* overflow */ | ||
1291 | PyErr_NoMemory(); | ||
1292 | goto Done; | ||
1293 | } | ||
1294 | if (_PyBytes_Resize(&newfmt, bigger) < 0) | ||
1295 | goto Done; | ||
1296 | totalnew = bigger; | ||
1297 | pnew = PyBytes_AsString(newfmt) + usednew; | ||
1298 | } | ||
1299 | memcpy(pnew, ptoappend, ntoappend)((__builtin_object_size (pnew, 0) != (size_t) -1) ? __builtin___memcpy_chk (pnew, ptoappend, ntoappend, __builtin_object_size (pnew, 0) ) : __inline_memcpy_chk (pnew, ptoappend, ntoappend)); | ||
1300 | pnew += ntoappend; | ||
1301 | usednew += ntoappend; | ||
1302 | assert(usednew <= totalnew)(__builtin_expect(!(usednew <= totalnew), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1302, "usednew <= totalnew") : (void)0); | ||
1303 | } /* end while() */ | ||
1304 | |||
1305 | if (_PyBytes_Resize(&newfmt, usednew) < 0) | ||
1306 | goto Done; | ||
1307 | { | ||
1308 | PyObject *format; | ||
1309 | PyObject *time = PyImport_ImportModuleNoBlock("time"); | ||
1310 | if (time == NULL((void*)0)) | ||
1311 | goto Done; | ||
1312 | format = PyUnicode_FromStringPyUnicodeUCS2_FromString(PyBytes_AS_STRING(newfmt)((__builtin_expect(!(((((((PyObject*)(newfmt))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1312, "PyBytes_Check(newfmt)") : (void)0), (((PyBytesObject *)(newfmt))->ob_sval))); | ||
1313 | if (format != NULL((void*)0)) { | ||
1314 | result = PyObject_CallMethod(time, "strftime", "OO", | ||
1315 | format, timetuple, NULL((void*)0)); | ||
1316 | Py_DECREF(format)do { if (_Py_RefTotal-- , --((PyObject*)(format))->ob_refcnt != 0) { if (((PyObject*)format)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1316, (PyObject *)(format)); } else _Py_Dealloc((PyObject * )(format)); } while (0); | ||
1317 | } | ||
1318 | Py_DECREF(time)do { if (_Py_RefTotal-- , --((PyObject*)(time))->ob_refcnt != 0) { if (((PyObject*)time)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1318, (PyObject *)(time)); } else _Py_Dealloc((PyObject *)( time)); } while (0); | ||
1319 | } | ||
1320 | Done: | ||
1321 | Py_XDECREF(freplacement)do { if ((freplacement) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(freplacement))->ob_refcnt != 0) { if ( ((PyObject*)freplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1321, (PyObject *)(freplacement)); } else _Py_Dealloc((PyObject *)(freplacement)); } while (0); } while (0); | ||
1322 | Py_XDECREF(zreplacement)do { if ((zreplacement) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(zreplacement))->ob_refcnt != 0) { if ( ((PyObject*)zreplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1322, (PyObject *)(zreplacement)); } else _Py_Dealloc((PyObject *)(zreplacement)); } while (0); } while (0); | ||
1323 | Py_XDECREF(Zreplacement)do { if ((Zreplacement) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(Zreplacement))->ob_refcnt != 0) { if ( ((PyObject*)Zreplacement)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1323, (PyObject *)(Zreplacement)); } else _Py_Dealloc((PyObject *)(Zreplacement)); } while (0); } while (0); | ||
1324 | Py_XDECREF(newfmt)do { if ((newfmt) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(newfmt))->ob_refcnt != 0) { if (((PyObject *)newfmt)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1324, (PyObject *)(newfmt)); } else _Py_Dealloc((PyObject * )(newfmt)); } while (0); } while (0); | ||
1325 | return result; | ||
1326 | } | ||
1327 | |||
1328 | /* --------------------------------------------------------------------------- | ||
1329 | * Wrap functions from the time module. These aren't directly available | ||
1330 | * from C. Perhaps they should be. | ||
1331 | */ | ||
1332 | |||
1333 | /* Call time.time() and return its result (a Python float). */ | ||
1334 | static PyObject * | ||
1335 | time_time(void) | ||
1336 | { | ||
1337 | PyObject *result = NULL((void*)0); | ||
1338 | PyObject *time = PyImport_ImportModuleNoBlock("time"); | ||
1339 | |||
1340 | if (time != NULL((void*)0)) { | ||
1341 | result = PyObject_CallMethod(time, "time", "()"); | ||
1342 | Py_DECREF(time)do { if (_Py_RefTotal-- , --((PyObject*)(time))->ob_refcnt != 0) { if (((PyObject*)time)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1342, (PyObject *)(time)); } else _Py_Dealloc((PyObject *)( time)); } while (0); | ||
1343 | } | ||
1344 | return result; | ||
1345 | } | ||
1346 | |||
1347 | /* Build a time.struct_time. The weekday and day number are automatically | ||
1348 | * computed from the y,m,d args. | ||
1349 | */ | ||
1350 | static PyObject * | ||
1351 | build_struct_time(int y, int m, int d, int hh, int mm, int ss, int dstflag) | ||
1352 | { | ||
1353 | PyObject *time; | ||
1354 | PyObject *result = NULL((void*)0); | ||
1355 | |||
1356 | time = PyImport_ImportModuleNoBlock("time"); | ||
1357 | if (time != NULL((void*)0)) { | ||
1358 | result = PyObject_CallMethod(time, "struct_time", | ||
1359 | "((iiiiiiiii))", | ||
1360 | y, m, d, | ||
1361 | hh, mm, ss, | ||
1362 | weekday(y, m, d), | ||
1363 | days_before_month(y, m) + d, | ||
1364 | dstflag); | ||
1365 | Py_DECREF(time)do { if (_Py_RefTotal-- , --((PyObject*)(time))->ob_refcnt != 0) { if (((PyObject*)time)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1365, (PyObject *)(time)); } else _Py_Dealloc((PyObject *)( time)); } while (0); | ||
1366 | } | ||
1367 | return result; | ||
1368 | } | ||
1369 | |||
1370 | /* --------------------------------------------------------------------------- | ||
1371 | * Miscellaneous helpers. | ||
1372 | */ | ||
1373 | |||
1374 | /* For various reasons, we need to use tp_richcompare instead of tp_reserved. | ||
1375 | * The comparisons here all most naturally compute a cmp()-like result. | ||
1376 | * This little helper turns that into a bool result for rich comparisons. | ||
1377 | */ | ||
1378 | static PyObject * | ||
1379 | diff_to_bool(int diff, int op) | ||
1380 | { | ||
1381 | PyObject *result; | ||
1382 | int istrue; | ||
1383 | |||
1384 | switch (op) { | ||
1385 | case Py_EQ2: istrue = diff == 0; break; | ||
1386 | case Py_NE3: istrue = diff != 0; break; | ||
1387 | case Py_LE1: istrue = diff <= 0; break; | ||
1388 | case Py_GE5: istrue = diff >= 0; break; | ||
1389 | case Py_LT0: istrue = diff < 0; break; | ||
1390 | case Py_GT4: istrue = diff > 0; break; | ||
1391 | default: | ||
1392 | assert(! "op unknown")(__builtin_expect(!(! "op unknown"), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1392, "! \"op unknown\"") : (void)0); | ||
1393 | istrue = 0; /* To shut up compiler */ | ||
1394 | } | ||
1395 | result = istrue ? Py_True((PyObject *) &_Py_TrueStruct) : Py_False((PyObject *) &_Py_FalseStruct); | ||
1396 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1397 | return result; | ||
1398 | } | ||
1399 | |||
1400 | /* Raises a "can't compare" TypeError and returns NULL. */ | ||
1401 | static PyObject * | ||
1402 | cmperror(PyObject *a, PyObject *b) | ||
1403 | { | ||
1404 | PyErr_Format(PyExc_TypeError, | ||
1405 | "can't compare %s to %s", | ||
1406 | Py_TYPE(a)(((PyObject*)(a))->ob_type)->tp_name, Py_TYPE(b)(((PyObject*)(b))->ob_type)->tp_name); | ||
1407 | return NULL((void*)0); | ||
1408 | } | ||
1409 | |||
1410 | /* --------------------------------------------------------------------------- | ||
1411 | * Cached Python objects; these are set by the module init function. | ||
1412 | */ | ||
1413 | |||
1414 | /* Conversion factors. */ | ||
1415 | static PyObject *us_per_us = NULL((void*)0); /* 1 */ | ||
1416 | static PyObject *us_per_ms = NULL((void*)0); /* 1000 */ | ||
1417 | static PyObject *us_per_second = NULL((void*)0); /* 1000000 */ | ||
1418 | static PyObject *us_per_minute = NULL((void*)0); /* 1e6 * 60 as Python int */ | ||
1419 | static PyObject *us_per_hour = NULL((void*)0); /* 1e6 * 3600 as Python long */ | ||
1420 | static PyObject *us_per_day = NULL((void*)0); /* 1e6 * 3600 * 24 as Python long */ | ||
1421 | static PyObject *us_per_week = NULL((void*)0); /* 1e6*3600*24*7 as Python long */ | ||
1422 | static PyObject *seconds_per_day = NULL((void*)0); /* 3600*24 as Python int */ | ||
1423 | |||
1424 | /* --------------------------------------------------------------------------- | ||
1425 | * Class implementations. | ||
1426 | */ | ||
1427 | |||
1428 | /* | ||
1429 | * PyDateTime_Delta implementation. | ||
1430 | */ | ||
1431 | |||
1432 | /* Convert a timedelta to a number of us, | ||
1433 | * (24*3600*self.days + self.seconds)*1000000 + self.microseconds | ||
1434 | * as a Python int or long. | ||
1435 | * Doing mixed-radix arithmetic by hand instead is excruciating in C, | ||
1436 | * due to ubiquitous overflow possibilities. | ||
1437 | */ | ||
1438 | static PyObject * | ||
1439 | delta_to_microseconds(PyDateTime_Delta *self) | ||
1440 | { | ||
1441 | PyObject *x1 = NULL((void*)0); | ||
1442 | PyObject *x2 = NULL((void*)0); | ||
1443 | PyObject *x3 = NULL((void*)0); | ||
1444 | PyObject *result = NULL((void*)0); | ||
1445 | |||
1446 | x1 = PyLong_FromLong(GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days)); | ||
1447 | if (x1 == NULL((void*)0)) | ||
1448 | goto Done; | ||
1449 | x2 = PyNumber_Multiply(x1, seconds_per_day); /* days in seconds */ | ||
1450 | if (x2 == NULL((void*)0)) | ||
1451 | goto Done; | ||
1452 | Py_DECREF(x1)do { if (_Py_RefTotal-- , --((PyObject*)(x1))->ob_refcnt != 0) { if (((PyObject*)x1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1452, (PyObject *)(x1)); } else _Py_Dealloc((PyObject *)(x1 )); } while (0); | ||
1453 | x1 = NULL((void*)0); | ||
1454 | |||
1455 | /* x2 has days in seconds */ | ||
1456 | x1 = PyLong_FromLong(GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds)); /* seconds */ | ||
1457 | if (x1 == NULL((void*)0)) | ||
1458 | goto Done; | ||
1459 | x3 = PyNumber_Add(x1, x2); /* days and seconds in seconds */ | ||
1460 | if (x3 == NULL((void*)0)) | ||
1461 | goto Done; | ||
1462 | Py_DECREF(x1)do { if (_Py_RefTotal-- , --((PyObject*)(x1))->ob_refcnt != 0) { if (((PyObject*)x1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1462, (PyObject *)(x1)); } else _Py_Dealloc((PyObject *)(x1 )); } while (0); | ||
1463 | Py_DECREF(x2)do { if (_Py_RefTotal-- , --((PyObject*)(x2))->ob_refcnt != 0) { if (((PyObject*)x2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1463, (PyObject *)(x2)); } else _Py_Dealloc((PyObject *)(x2 )); } while (0); | ||
1464 | x1 = x2 = NULL((void*)0); | ||
1465 | |||
1466 | /* x3 has days+seconds in seconds */ | ||
1467 | x1 = PyNumber_Multiply(x3, us_per_second); /* us */ | ||
1468 | if (x1 == NULL((void*)0)) | ||
1469 | goto Done; | ||
1470 | Py_DECREF(x3)do { if (_Py_RefTotal-- , --((PyObject*)(x3))->ob_refcnt != 0) { if (((PyObject*)x3)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1470, (PyObject *)(x3)); } else _Py_Dealloc((PyObject *)(x3 )); } while (0); | ||
1471 | x3 = NULL((void*)0); | ||
1472 | |||
1473 | /* x1 has days+seconds in us */ | ||
1474 | x2 = PyLong_FromLong(GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds)); | ||
1475 | if (x2 == NULL((void*)0)) | ||
1476 | goto Done; | ||
1477 | result = PyNumber_Add(x1, x2); | ||
1478 | |||
1479 | Done: | ||
1480 | Py_XDECREF(x1)do { if ((x1) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(x1))->ob_refcnt != 0) { if (((PyObject*)x1 )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1480, (PyObject *)(x1)); } else _Py_Dealloc((PyObject *)(x1 )); } while (0); } while (0); | ||
1481 | Py_XDECREF(x2)do { if ((x2) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(x2))->ob_refcnt != 0) { if (((PyObject*)x2 )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1481, (PyObject *)(x2)); } else _Py_Dealloc((PyObject *)(x2 )); } while (0); } while (0); | ||
1482 | Py_XDECREF(x3)do { if ((x3) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(x3))->ob_refcnt != 0) { if (((PyObject*)x3 )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1482, (PyObject *)(x3)); } else _Py_Dealloc((PyObject *)(x3 )); } while (0); } while (0); | ||
1483 | return result; | ||
1484 | } | ||
1485 | |||
1486 | /* Convert a number of us (as a Python int or long) to a timedelta. | ||
1487 | */ | ||
1488 | static PyObject * | ||
1489 | microseconds_to_delta_ex(PyObject *pyus, PyTypeObject *type) | ||
1490 | { | ||
1491 | int us; | ||
1492 | int s; | ||
1493 | int d; | ||
1494 | long temp; | ||
1495 | |||
1496 | PyObject *tuple = NULL((void*)0); | ||
1497 | PyObject *num = NULL((void*)0); | ||
1498 | PyObject *result = NULL((void*)0); | ||
1499 | |||
1500 | tuple = PyNumber_Divmod(pyus, us_per_second); | ||
1501 | if (tuple == NULL((void*)0)) | ||
| |||
1502 | goto Done; | ||
1503 | |||
1504 | num = PyTuple_GetItem(tuple, 1); /* us */ | ||
1505 | if (num == NULL((void*)0)) | ||
| |||
1506 | goto Done; | ||
1507 | temp = PyLong_AsLong(num); | ||
1508 | num = NULL((void*)0); | ||
1509 | if (temp == -1 && PyErr_Occurred()) | ||
| |||
1510 | goto Done; | ||
1511 | assert(0 <= temp && temp < 1000000)(__builtin_expect(!(0 <= temp && temp < 1000000 ), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1511, "0 <= temp && temp < 1000000") : (void) 0); | ||
1512 | us = (int)temp; | ||
1513 | if (us < 0) { | ||
| |||
1514 | /* The divisor was positive, so this must be an error. */ | ||
1515 | assert(PyErr_Occurred())(__builtin_expect(!(PyErr_Occurred()), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1515, "PyErr_Occurred()") : (void)0); | ||
1516 | goto Done; | ||
1517 | } | ||
1518 | |||
1519 | num = PyTuple_GetItem(tuple, 0); /* leftover seconds */ | ||
1520 | if (num == NULL((void*)0)) | ||
| |||
1521 | goto Done; | ||
1522 | Py_INCREF(num)( _Py_RefTotal++ , ((PyObject*)(num))->ob_refcnt++); | ||
1523 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1523, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
1524 | |||
1525 | tuple = PyNumber_Divmod(num, seconds_per_day); | ||
1526 | if (tuple == NULL((void*)0)) | ||
| |||
1527 | goto Done; | ||
1528 | Py_DECREF(num)do { if (_Py_RefTotal-- , --((PyObject*)(num))->ob_refcnt != 0) { if (((PyObject*)num)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1528, (PyObject *)(num)); } else _Py_Dealloc((PyObject *)(num )); } while (0); | ||
1529 | |||
1530 | num = PyTuple_GetItem(tuple, 1); /* seconds */ | ||
1531 | if (num == NULL((void*)0)) | ||
| |||
1532 | goto Done; | ||
1533 | temp = PyLong_AsLong(num); | ||
1534 | num = NULL((void*)0); | ||
1535 | if (temp == -1 && PyErr_Occurred()) | ||
| |||
1536 | goto Done; | ||
1537 | assert(0 <= temp && temp < 24*3600)(__builtin_expect(!(0 <= temp && temp < 24*3600 ), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1537, "0 <= temp && temp < 24*3600") : (void) 0); | ||
1538 | s = (int)temp; | ||
1539 | |||
1540 | if (s < 0) { | ||
| |||
1541 | /* The divisor was positive, so this must be an error. */ | ||
1542 | assert(PyErr_Occurred())(__builtin_expect(!(PyErr_Occurred()), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1542, "PyErr_Occurred()") : (void)0); | ||
1543 | goto Done; | ||
1544 | } | ||
1545 | |||
1546 | num = PyTuple_GetItem(tuple, 0); /* leftover days */ | ||
1547 | if (num == NULL((void*)0)) | ||
| |||
1548 | goto Done; | ||
1549 | Py_INCREF(num)( _Py_RefTotal++ , ((PyObject*)(num))->ob_refcnt++); | ||
1550 | temp = PyLong_AsLong(num); | ||
1551 | if (temp == -1 && PyErr_Occurred()) | ||
| |||
1552 | goto Done; | ||
1553 | d = (int)temp; | ||
1554 | if ((long)d != temp) { | ||
| |||
1555 | PyErr_SetString(PyExc_OverflowError, "normalized days too " | ||
1556 | "large to fit in a C int"); | ||
1557 | goto Done; | ||
1558 | } | ||
1559 | result = new_delta_ex(d, s, us, 0, type); | ||
1560 | |||
1561 | Done: | ||
1562 | Py_XDECREF(tuple)do { if ((tuple) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject *)tuple)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1562, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); } while (0); | ||
1563 | Py_XDECREF(num)do { if ((num) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(num))->ob_refcnt != 0) { if (((PyObject*)num )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1563, (PyObject *)(num)); } else _Py_Dealloc((PyObject *)(num )); } while (0); } while (0); | ||
1564 | return result; | ||
1565 | } | ||
1566 | |||
1567 | #define microseconds_to_delta(pymicros)microseconds_to_delta_ex(pymicros, &PyDateTime_DeltaType) \ | ||
1568 | microseconds_to_delta_ex(pymicros, &PyDateTime_DeltaType) | ||
1569 | |||
1570 | static PyObject * | ||
1571 | multiply_int_timedelta(PyObject *intobj, PyDateTime_Delta *delta) | ||
1572 | { | ||
1573 | PyObject *pyus_in; | ||
1574 | PyObject *pyus_out; | ||
1575 | PyObject *result; | ||
1576 | |||
1577 | pyus_in = delta_to_microseconds(delta); | ||
1578 | if (pyus_in == NULL((void*)0)) | ||
1579 | return NULL((void*)0); | ||
1580 | |||
1581 | pyus_out = PyNumber_Multiply(pyus_in, intobj); | ||
1582 | Py_DECREF(pyus_in)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject*)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1582, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); | ||
1583 | if (pyus_out == NULL((void*)0)) | ||
1584 | return NULL((void*)0); | ||
1585 | |||
1586 | result = microseconds_to_delta(pyus_out)microseconds_to_delta_ex(pyus_out, &PyDateTime_DeltaType); | ||
1587 | Py_DECREF(pyus_out)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_out))->ob_refcnt != 0) { if (((PyObject*)pyus_out)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1587, (PyObject *)(pyus_out)); } else _Py_Dealloc((PyObject *)(pyus_out)); } while (0); | ||
1588 | return result; | ||
1589 | } | ||
1590 | |||
1591 | static PyObject * | ||
1592 | multiply_float_timedelta(PyObject *floatobj, PyDateTime_Delta *delta) | ||
1593 | { | ||
1594 | PyObject *result = NULL((void*)0); | ||
1595 | PyObject *pyus_in = NULL((void*)0), *temp, *pyus_out; | ||
1596 | PyObject *ratio = NULL((void*)0); | ||
1597 | |||
1598 | pyus_in = delta_to_microseconds(delta); | ||
1599 | if (pyus_in == NULL((void*)0)) | ||
1600 | return NULL((void*)0); | ||
1601 | ratio = PyObject_CallMethod(floatobj, "as_integer_ratio", NULL((void*)0)); | ||
1602 | if (ratio == NULL((void*)0)) | ||
1603 | goto error; | ||
1604 | temp = PyNumber_Multiply(pyus_in, PyTuple_GET_ITEM(ratio, 0)(((PyTupleObject *)(ratio))->ob_item[0])); | ||
1605 | Py_DECREF(pyus_in)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject*)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1605, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); | ||
1606 | pyus_in = NULL((void*)0); | ||
1607 | if (temp == NULL((void*)0)) | ||
1608 | goto error; | ||
1609 | pyus_out = divide_nearest(temp, PyTuple_GET_ITEM(ratio, 1)(((PyTupleObject *)(ratio))->ob_item[1])); | ||
1610 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1610, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1611 | if (pyus_out == NULL((void*)0)) | ||
1612 | goto error; | ||
1613 | result = microseconds_to_delta(pyus_out)microseconds_to_delta_ex(pyus_out, &PyDateTime_DeltaType); | ||
1614 | Py_DECREF(pyus_out)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_out))->ob_refcnt != 0) { if (((PyObject*)pyus_out)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1614, (PyObject *)(pyus_out)); } else _Py_Dealloc((PyObject *)(pyus_out)); } while (0); | ||
1615 | error: | ||
1616 | Py_XDECREF(pyus_in)do { if ((pyus_in) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject *)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1616, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); } while (0); | ||
1617 | Py_XDECREF(ratio)do { if ((ratio) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(ratio))->ob_refcnt != 0) { if (((PyObject *)ratio)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1617, (PyObject *)(ratio)); } else _Py_Dealloc((PyObject *) (ratio)); } while (0); } while (0); | ||
1618 | |||
1619 | return result; | ||
1620 | } | ||
1621 | |||
1622 | static PyObject * | ||
1623 | divide_timedelta_int(PyDateTime_Delta *delta, PyObject *intobj) | ||
1624 | { | ||
1625 | PyObject *pyus_in; | ||
1626 | PyObject *pyus_out; | ||
1627 | PyObject *result; | ||
1628 | |||
1629 | pyus_in = delta_to_microseconds(delta); | ||
1630 | if (pyus_in == NULL((void*)0)) | ||
1631 | return NULL((void*)0); | ||
1632 | |||
1633 | pyus_out = PyNumber_FloorDivide(pyus_in, intobj); | ||
1634 | Py_DECREF(pyus_in)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject*)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1634, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); | ||
1635 | if (pyus_out == NULL((void*)0)) | ||
1636 | return NULL((void*)0); | ||
1637 | |||
1638 | result = microseconds_to_delta(pyus_out)microseconds_to_delta_ex(pyus_out, &PyDateTime_DeltaType); | ||
1639 | Py_DECREF(pyus_out)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_out))->ob_refcnt != 0) { if (((PyObject*)pyus_out)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1639, (PyObject *)(pyus_out)); } else _Py_Dealloc((PyObject *)(pyus_out)); } while (0); | ||
1640 | return result; | ||
1641 | } | ||
1642 | |||
1643 | static PyObject * | ||
1644 | divide_timedelta_timedelta(PyDateTime_Delta *left, PyDateTime_Delta *right) | ||
1645 | { | ||
1646 | PyObject *pyus_left; | ||
1647 | PyObject *pyus_right; | ||
1648 | PyObject *result; | ||
1649 | |||
1650 | pyus_left = delta_to_microseconds(left); | ||
1651 | if (pyus_left == NULL((void*)0)) | ||
1652 | return NULL((void*)0); | ||
1653 | |||
1654 | pyus_right = delta_to_microseconds(right); | ||
1655 | if (pyus_right == NULL((void*)0)) { | ||
1656 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1656, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1657 | return NULL((void*)0); | ||
1658 | } | ||
1659 | |||
1660 | result = PyNumber_FloorDivide(pyus_left, pyus_right); | ||
1661 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1661, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1662 | Py_DECREF(pyus_right)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_right))->ob_refcnt != 0) { if (((PyObject*)pyus_right)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1662, (PyObject *)(pyus_right)); } else _Py_Dealloc((PyObject *)(pyus_right)); } while (0); | ||
1663 | return result; | ||
1664 | } | ||
1665 | |||
1666 | static PyObject * | ||
1667 | truedivide_timedelta_timedelta(PyDateTime_Delta *left, PyDateTime_Delta *right) | ||
1668 | { | ||
1669 | PyObject *pyus_left; | ||
1670 | PyObject *pyus_right; | ||
1671 | PyObject *result; | ||
1672 | |||
1673 | pyus_left = delta_to_microseconds(left); | ||
1674 | if (pyus_left == NULL((void*)0)) | ||
1675 | return NULL((void*)0); | ||
1676 | |||
1677 | pyus_right = delta_to_microseconds(right); | ||
1678 | if (pyus_right == NULL((void*)0)) { | ||
1679 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1679, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1680 | return NULL((void*)0); | ||
1681 | } | ||
1682 | |||
1683 | result = PyNumber_TrueDivide(pyus_left, pyus_right); | ||
1684 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1684, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1685 | Py_DECREF(pyus_right)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_right))->ob_refcnt != 0) { if (((PyObject*)pyus_right)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1685, (PyObject *)(pyus_right)); } else _Py_Dealloc((PyObject *)(pyus_right)); } while (0); | ||
1686 | return result; | ||
1687 | } | ||
1688 | |||
1689 | static PyObject * | ||
1690 | truedivide_timedelta_float(PyDateTime_Delta *delta, PyObject *f) | ||
1691 | { | ||
1692 | PyObject *result = NULL((void*)0); | ||
1693 | PyObject *pyus_in = NULL((void*)0), *temp, *pyus_out; | ||
1694 | PyObject *ratio = NULL((void*)0); | ||
1695 | |||
1696 | pyus_in = delta_to_microseconds(delta); | ||
1697 | if (pyus_in == NULL((void*)0)) | ||
1698 | return NULL((void*)0); | ||
1699 | ratio = PyObject_CallMethod(f, "as_integer_ratio", NULL((void*)0)); | ||
1700 | if (ratio == NULL((void*)0)) | ||
1701 | goto error; | ||
1702 | temp = PyNumber_Multiply(pyus_in, PyTuple_GET_ITEM(ratio, 1)(((PyTupleObject *)(ratio))->ob_item[1])); | ||
1703 | Py_DECREF(pyus_in)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject*)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1703, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); | ||
1704 | pyus_in = NULL((void*)0); | ||
1705 | if (temp == NULL((void*)0)) | ||
1706 | goto error; | ||
1707 | pyus_out = divide_nearest(temp, PyTuple_GET_ITEM(ratio, 0)(((PyTupleObject *)(ratio))->ob_item[0])); | ||
1708 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1708, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1709 | if (pyus_out == NULL((void*)0)) | ||
1710 | goto error; | ||
1711 | result = microseconds_to_delta(pyus_out)microseconds_to_delta_ex(pyus_out, &PyDateTime_DeltaType); | ||
1712 | Py_DECREF(pyus_out)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_out))->ob_refcnt != 0) { if (((PyObject*)pyus_out)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1712, (PyObject *)(pyus_out)); } else _Py_Dealloc((PyObject *)(pyus_out)); } while (0); | ||
1713 | error: | ||
1714 | Py_XDECREF(pyus_in)do { if ((pyus_in) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject *)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1714, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); } while (0); | ||
1715 | Py_XDECREF(ratio)do { if ((ratio) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(ratio))->ob_refcnt != 0) { if (((PyObject *)ratio)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1715, (PyObject *)(ratio)); } else _Py_Dealloc((PyObject *) (ratio)); } while (0); } while (0); | ||
1716 | |||
1717 | return result; | ||
1718 | } | ||
1719 | |||
1720 | static PyObject * | ||
1721 | truedivide_timedelta_int(PyDateTime_Delta *delta, PyObject *i) | ||
1722 | { | ||
1723 | PyObject *result; | ||
1724 | PyObject *pyus_in, *pyus_out; | ||
1725 | pyus_in = delta_to_microseconds(delta); | ||
1726 | if (pyus_in == NULL((void*)0)) | ||
1727 | return NULL((void*)0); | ||
1728 | pyus_out = divide_nearest(pyus_in, i); | ||
1729 | Py_DECREF(pyus_in)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_in))->ob_refcnt != 0) { if (((PyObject*)pyus_in)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1729, (PyObject *)(pyus_in)); } else _Py_Dealloc((PyObject * )(pyus_in)); } while (0); | ||
1730 | if (pyus_out == NULL((void*)0)) | ||
1731 | return NULL((void*)0); | ||
1732 | result = microseconds_to_delta(pyus_out)microseconds_to_delta_ex(pyus_out, &PyDateTime_DeltaType); | ||
1733 | Py_DECREF(pyus_out)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_out))->ob_refcnt != 0) { if (((PyObject*)pyus_out)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1733, (PyObject *)(pyus_out)); } else _Py_Dealloc((PyObject *)(pyus_out)); } while (0); | ||
1734 | |||
1735 | return result; | ||
1736 | } | ||
1737 | |||
1738 | static PyObject * | ||
1739 | delta_add(PyObject *left, PyObject *right) | ||
1740 | { | ||
1741 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1742 | |||
1743 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType))) && PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1744 | /* delta + delta */ | ||
1745 | /* The C-level additions can't overflow because of the | ||
1746 | * invariant bounds. | ||
1747 | */ | ||
1748 | int days = GET_TD_DAYS(left)(((PyDateTime_Delta *)(left))->days) + GET_TD_DAYS(right)(((PyDateTime_Delta *)(right))->days); | ||
1749 | int seconds = GET_TD_SECONDS(left)(((PyDateTime_Delta *)(left))->seconds) + GET_TD_SECONDS(right)(((PyDateTime_Delta *)(right))->seconds); | ||
1750 | int microseconds = GET_TD_MICROSECONDS(left)(((PyDateTime_Delta *)(left))->microseconds) + | ||
1751 | GET_TD_MICROSECONDS(right)(((PyDateTime_Delta *)(right))->microseconds); | ||
1752 | result = new_delta(days, seconds, microseconds, 1)new_delta_ex(days, seconds, microseconds, 1, &PyDateTime_DeltaType ); | ||
1753 | } | ||
1754 | |||
1755 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
1756 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1757 | return result; | ||
1758 | } | ||
1759 | |||
1760 | static PyObject * | ||
1761 | delta_negative(PyDateTime_Delta *self) | ||
1762 | { | ||
1763 | return new_delta(-GET_TD_DAYS(self),new_delta_ex(-(((PyDateTime_Delta *)(self))->days), -(((PyDateTime_Delta *)(self))->seconds), -(((PyDateTime_Delta *)(self))->microseconds ), 1, &PyDateTime_DeltaType) | ||
1764 | -GET_TD_SECONDS(self),new_delta_ex(-(((PyDateTime_Delta *)(self))->days), -(((PyDateTime_Delta *)(self))->seconds), -(((PyDateTime_Delta *)(self))->microseconds ), 1, &PyDateTime_DeltaType) | ||
1765 | -GET_TD_MICROSECONDS(self),new_delta_ex(-(((PyDateTime_Delta *)(self))->days), -(((PyDateTime_Delta *)(self))->seconds), -(((PyDateTime_Delta *)(self))->microseconds ), 1, &PyDateTime_DeltaType) | ||
1766 | 1)new_delta_ex(-(((PyDateTime_Delta *)(self))->days), -(((PyDateTime_Delta *)(self))->seconds), -(((PyDateTime_Delta *)(self))->microseconds ), 1, &PyDateTime_DeltaType); | ||
1767 | } | ||
1768 | |||
1769 | static PyObject * | ||
1770 | delta_positive(PyDateTime_Delta *self) | ||
1771 | { | ||
1772 | /* Could optimize this (by returning self) if this isn't a | ||
1773 | * subclass -- but who uses unary + ? Approximately nobody. | ||
1774 | */ | ||
1775 | return new_delta(GET_TD_DAYS(self),new_delta_ex((((PyDateTime_Delta *)(self))->days), (((PyDateTime_Delta *)(self))->seconds), (((PyDateTime_Delta *)(self))->microseconds ), 0, &PyDateTime_DeltaType) | ||
1776 | GET_TD_SECONDS(self),new_delta_ex((((PyDateTime_Delta *)(self))->days), (((PyDateTime_Delta *)(self))->seconds), (((PyDateTime_Delta *)(self))->microseconds ), 0, &PyDateTime_DeltaType) | ||
1777 | GET_TD_MICROSECONDS(self),new_delta_ex((((PyDateTime_Delta *)(self))->days), (((PyDateTime_Delta *)(self))->seconds), (((PyDateTime_Delta *)(self))->microseconds ), 0, &PyDateTime_DeltaType) | ||
1778 | 0)new_delta_ex((((PyDateTime_Delta *)(self))->days), (((PyDateTime_Delta *)(self))->seconds), (((PyDateTime_Delta *)(self))->microseconds ), 0, &PyDateTime_DeltaType); | ||
1779 | } | ||
1780 | |||
1781 | static PyObject * | ||
1782 | delta_abs(PyDateTime_Delta *self) | ||
1783 | { | ||
1784 | PyObject *result; | ||
1785 | |||
1786 | assert(GET_TD_MICROSECONDS(self) >= 0)(__builtin_expect(!((((PyDateTime_Delta *)(self))->microseconds ) >= 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1786, "GET_TD_MICROSECONDS(self) >= 0") : (void)0); | ||
1787 | assert(GET_TD_SECONDS(self) >= 0)(__builtin_expect(!((((PyDateTime_Delta *)(self))->seconds ) >= 0), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1787, "GET_TD_SECONDS(self) >= 0") : (void)0); | ||
1788 | |||
1789 | if (GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days) < 0) | ||
1790 | result = delta_negative(self); | ||
1791 | else | ||
1792 | result = delta_positive(self); | ||
1793 | |||
1794 | return result; | ||
1795 | } | ||
1796 | |||
1797 | static PyObject * | ||
1798 | delta_subtract(PyObject *left, PyObject *right) | ||
1799 | { | ||
1800 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1801 | |||
1802 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType))) && PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1803 | /* delta - delta */ | ||
1804 | PyObject *minus_right = PyNumber_Negative(right); | ||
1805 | if (minus_right) { | ||
1806 | result = delta_add(left, minus_right); | ||
1807 | Py_DECREF(minus_right)do { if (_Py_RefTotal-- , --((PyObject*)(minus_right))->ob_refcnt != 0) { if (((PyObject*)minus_right)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1807, (PyObject *)(minus_right)); } else _Py_Dealloc((PyObject *)(minus_right)); } while (0); | ||
1808 | } | ||
1809 | else | ||
1810 | result = NULL((void*)0); | ||
1811 | } | ||
1812 | |||
1813 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
1814 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1815 | return result; | ||
1816 | } | ||
1817 | |||
1818 | static int | ||
1819 | delta_cmp(PyObject *self, PyObject *other) | ||
1820 | { | ||
1821 | int diff = GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days) - GET_TD_DAYS(other)(((PyDateTime_Delta *)(other))->days); | ||
1822 | if (diff == 0) { | ||
1823 | diff = GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds) - GET_TD_SECONDS(other)(((PyDateTime_Delta *)(other))->seconds); | ||
1824 | if (diff == 0) | ||
1825 | diff = GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds) - | ||
1826 | GET_TD_MICROSECONDS(other)(((PyDateTime_Delta *)(other))->microseconds); | ||
1827 | } | ||
1828 | return diff; | ||
1829 | } | ||
1830 | |||
1831 | static PyObject * | ||
1832 | delta_richcompare(PyObject *self, PyObject *other, int op) | ||
1833 | { | ||
1834 | if (PyDelta_Check(other)((((PyObject*)(other))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(other))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1835 | int diff = delta_cmp(self, other); | ||
1836 | return diff_to_bool(diff, op); | ||
1837 | } | ||
1838 | else { | ||
1839 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
1840 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1841 | } | ||
1842 | } | ||
1843 | |||
1844 | static PyObject *delta_getstate(PyDateTime_Delta *self); | ||
1845 | |||
1846 | static Py_hash_t | ||
1847 | delta_hash(PyDateTime_Delta *self) | ||
1848 | { | ||
1849 | if (self->hashcode == -1) { | ||
1850 | PyObject *temp = delta_getstate(self); | ||
1851 | if (temp != NULL((void*)0)) { | ||
1852 | self->hashcode = PyObject_Hash(temp); | ||
1853 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1853, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
1854 | } | ||
1855 | } | ||
1856 | return self->hashcode; | ||
1857 | } | ||
1858 | |||
1859 | static PyObject * | ||
1860 | delta_multiply(PyObject *left, PyObject *right) | ||
1861 | { | ||
1862 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1863 | |||
1864 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1865 | /* delta * ??? */ | ||
1866 | if (PyLong_Check(right)((((((PyObject*)(right))->ob_type))->tp_flags & ((1L <<24))) != 0)) | ||
1867 | result = multiply_int_timedelta(right, | ||
1868 | (PyDateTime_Delta *) left); | ||
1869 | else if (PyFloat_Check(right)((((PyObject*)(right))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (&PyFloat_Type )))) | ||
1870 | result = multiply_float_timedelta(right, | ||
1871 | (PyDateTime_Delta *) left); | ||
1872 | } | ||
1873 | else if (PyLong_Check(left)((((((PyObject*)(left))->ob_type))->tp_flags & ((1L <<24))) != 0)) | ||
1874 | result = multiply_int_timedelta(left, | ||
1875 | (PyDateTime_Delta *) right); | ||
1876 | else if (PyFloat_Check(left)((((PyObject*)(left))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype ((((PyObject*)(left))->ob_type), (&PyFloat_Type)))) | ||
1877 | result = multiply_float_timedelta(left, | ||
1878 | (PyDateTime_Delta *) right); | ||
1879 | |||
1880 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
1881 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1882 | return result; | ||
1883 | } | ||
1884 | |||
1885 | static PyObject * | ||
1886 | delta_divide(PyObject *left, PyObject *right) | ||
1887 | { | ||
1888 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1889 | |||
1890 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1891 | /* delta * ??? */ | ||
1892 | if (PyLong_Check(right)((((((PyObject*)(right))->ob_type))->tp_flags & ((1L <<24))) != 0)) | ||
1893 | result = divide_timedelta_int( | ||
1894 | (PyDateTime_Delta *)left, | ||
1895 | right); | ||
1896 | else if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) | ||
1897 | result = divide_timedelta_timedelta( | ||
1898 | (PyDateTime_Delta *)left, | ||
1899 | (PyDateTime_Delta *)right); | ||
1900 | } | ||
1901 | |||
1902 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
1903 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1904 | return result; | ||
1905 | } | ||
1906 | |||
1907 | static PyObject * | ||
1908 | delta_truedivide(PyObject *left, PyObject *right) | ||
1909 | { | ||
1910 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1911 | |||
1912 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1913 | if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) | ||
1914 | result = truedivide_timedelta_timedelta( | ||
1915 | (PyDateTime_Delta *)left, | ||
1916 | (PyDateTime_Delta *)right); | ||
1917 | else if (PyFloat_Check(right)((((PyObject*)(right))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (&PyFloat_Type )))) | ||
1918 | result = truedivide_timedelta_float( | ||
1919 | (PyDateTime_Delta *)left, right); | ||
1920 | else if (PyLong_Check(right)((((((PyObject*)(right))->ob_type))->tp_flags & ((1L <<24))) != 0)) | ||
1921 | result = truedivide_timedelta_int( | ||
1922 | (PyDateTime_Delta *)left, right); | ||
1923 | } | ||
1924 | |||
1925 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
1926 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
1927 | return result; | ||
1928 | } | ||
1929 | |||
1930 | static PyObject * | ||
1931 | delta_remainder(PyObject *left, PyObject *right) | ||
1932 | { | ||
1933 | PyObject *pyus_left; | ||
1934 | PyObject *pyus_right; | ||
1935 | PyObject *pyus_remainder; | ||
1936 | PyObject *remainder; | ||
1937 | |||
1938 | if (!PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType))) || !PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1939 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
1940 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1941 | } | ||
1942 | |||
1943 | pyus_left = delta_to_microseconds((PyDateTime_Delta *)left); | ||
1944 | if (pyus_left == NULL((void*)0)) | ||
1945 | return NULL((void*)0); | ||
1946 | |||
1947 | pyus_right = delta_to_microseconds((PyDateTime_Delta *)right); | ||
1948 | if (pyus_right == NULL((void*)0)) { | ||
1949 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1949, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1950 | return NULL((void*)0); | ||
1951 | } | ||
1952 | |||
1953 | pyus_remainder = PyNumber_Remainder(pyus_left, pyus_right); | ||
1954 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1954, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1955 | Py_DECREF(pyus_right)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_right))->ob_refcnt != 0) { if (((PyObject*)pyus_right)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1955, (PyObject *)(pyus_right)); } else _Py_Dealloc((PyObject *)(pyus_right)); } while (0); | ||
1956 | if (pyus_remainder == NULL((void*)0)) | ||
1957 | return NULL((void*)0); | ||
1958 | |||
1959 | remainder = microseconds_to_delta(pyus_remainder)microseconds_to_delta_ex(pyus_remainder, &PyDateTime_DeltaType ); | ||
1960 | Py_DECREF(pyus_remainder)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_remainder))-> ob_refcnt != 0) { if (((PyObject*)pyus_remainder)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1960, (PyObject *)(pyus_remainder)); } else _Py_Dealloc((PyObject *)(pyus_remainder)); } while (0); | ||
1961 | if (remainder == NULL((void*)0)) | ||
1962 | return NULL((void*)0); | ||
1963 | |||
1964 | return remainder; | ||
1965 | } | ||
1966 | |||
1967 | static PyObject * | ||
1968 | delta_divmod(PyObject *left, PyObject *right) | ||
1969 | { | ||
1970 | PyObject *pyus_left; | ||
1971 | PyObject *pyus_right; | ||
1972 | PyObject *divmod; | ||
1973 | PyObject *delta; | ||
1974 | PyObject *result; | ||
1975 | |||
1976 | if (!PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType))) || !PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
1977 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
1978 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
1979 | } | ||
1980 | |||
1981 | pyus_left = delta_to_microseconds((PyDateTime_Delta *)left); | ||
1982 | if (pyus_left == NULL((void*)0)) | ||
1983 | return NULL((void*)0); | ||
1984 | |||
1985 | pyus_right = delta_to_microseconds((PyDateTime_Delta *)right); | ||
1986 | if (pyus_right == NULL((void*)0)) { | ||
1987 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1987, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1988 | return NULL((void*)0); | ||
1989 | } | ||
1990 | |||
1991 | divmod = PyNumber_Divmod(pyus_left, pyus_right); | ||
1992 | Py_DECREF(pyus_left)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_left))->ob_refcnt != 0) { if (((PyObject*)pyus_left)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1992, (PyObject *)(pyus_left)); } else _Py_Dealloc((PyObject *)(pyus_left)); } while (0); | ||
1993 | Py_DECREF(pyus_right)do { if (_Py_RefTotal-- , --((PyObject*)(pyus_right))->ob_refcnt != 0) { if (((PyObject*)pyus_right)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1993, (PyObject *)(pyus_right)); } else _Py_Dealloc((PyObject *)(pyus_right)); } while (0); | ||
1994 | if (divmod == NULL((void*)0)) | ||
1995 | return NULL((void*)0); | ||
1996 | |||
1997 | assert(PyTuple_Size(divmod) == 2)(__builtin_expect(!(PyTuple_Size(divmod) == 2), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 1997, "PyTuple_Size(divmod) == 2") : (void)0); | ||
1998 | delta = microseconds_to_delta(PyTuple_GET_ITEM(divmod, 1))microseconds_to_delta_ex((((PyTupleObject *)(divmod))->ob_item [1]), &PyDateTime_DeltaType); | ||
1999 | if (delta == NULL((void*)0)) { | ||
2000 | Py_DECREF(divmod)do { if (_Py_RefTotal-- , --((PyObject*)(divmod))->ob_refcnt != 0) { if (((PyObject*)divmod)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2000, (PyObject *)(divmod)); } else _Py_Dealloc((PyObject * )(divmod)); } while (0); | ||
2001 | return NULL((void*)0); | ||
2002 | } | ||
2003 | result = PyTuple_Pack(2, PyTuple_GET_ITEM(divmod, 0)(((PyTupleObject *)(divmod))->ob_item[0]), delta); | ||
2004 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2004, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
2005 | Py_DECREF(divmod)do { if (_Py_RefTotal-- , --((PyObject*)(divmod))->ob_refcnt != 0) { if (((PyObject*)divmod)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2005, (PyObject *)(divmod)); } else _Py_Dealloc((PyObject * )(divmod)); } while (0); | ||
2006 | return result; | ||
2007 | } | ||
2008 | |||
2009 | /* Fold in the value of the tag ("seconds", "weeks", etc) component of a | ||
2010 | * timedelta constructor. sofar is the # of microseconds accounted for | ||
2011 | * so far, and there are factor microseconds per current unit, the number | ||
2012 | * of which is given by num. num * factor is added to sofar in a | ||
2013 | * numerically careful way, and that's the result. Any fractional | ||
2014 | * microseconds left over (this can happen if num is a float type) are | ||
2015 | * added into *leftover. | ||
2016 | * Note that there are many ways this can give an error (NULL) return. | ||
2017 | */ | ||
2018 | static PyObject * | ||
2019 | accum(const char* tag, PyObject *sofar, PyObject *num, PyObject *factor, | ||
2020 | double *leftover) | ||
2021 | { | ||
2022 | PyObject *prod; | ||
2023 | PyObject *sum; | ||
2024 | |||
2025 | assert(num != NULL)(__builtin_expect(!(num != ((void*)0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2025, "num != NULL") : (void)0); | ||
2026 | |||
2027 | if (PyLong_Check(num)((((((PyObject*)(num))->ob_type))->tp_flags & ((1L<< 24))) != 0)) { | ||
2028 | prod = PyNumber_Multiply(num, factor); | ||
2029 | if (prod == NULL((void*)0)) | ||
2030 | return NULL((void*)0); | ||
2031 | sum = PyNumber_Add(sofar, prod); | ||
2032 | Py_DECREF(prod)do { if (_Py_RefTotal-- , --((PyObject*)(prod))->ob_refcnt != 0) { if (((PyObject*)prod)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2032, (PyObject *)(prod)); } else _Py_Dealloc((PyObject *)( prod)); } while (0); | ||
2033 | return sum; | ||
2034 | } | ||
2035 | |||
2036 | if (PyFloat_Check(num)((((PyObject*)(num))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype ((((PyObject*)(num))->ob_type), (&PyFloat_Type)))) { | ||
2037 | double dnum; | ||
2038 | double fracpart; | ||
2039 | double intpart; | ||
2040 | PyObject *x; | ||
2041 | PyObject *y; | ||
2042 | |||
2043 | /* The Plan: decompose num into an integer part and a | ||
2044 | * fractional part, num = intpart + fracpart. | ||
2045 | * Then num * factor == | ||
2046 | * intpart * factor + fracpart * factor | ||
2047 | * and the LHS can be computed exactly in long arithmetic. | ||
2048 | * The RHS is again broken into an int part and frac part. | ||
2049 | * and the frac part is added into *leftover. | ||
2050 | */ | ||
2051 | dnum = PyFloat_AsDouble(num); | ||
2052 | if (dnum == -1.0 && PyErr_Occurred()) | ||
2053 | return NULL((void*)0); | ||
2054 | fracpart = modf(dnum, &intpart); | ||
2055 | x = PyLong_FromDouble(intpart); | ||
2056 | if (x == NULL((void*)0)) | ||
2057 | return NULL((void*)0); | ||
2058 | |||
2059 | prod = PyNumber_Multiply(x, factor); | ||
2060 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2060, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
2061 | if (prod == NULL((void*)0)) | ||
2062 | return NULL((void*)0); | ||
2063 | |||
2064 | sum = PyNumber_Add(sofar, prod); | ||
2065 | Py_DECREF(prod)do { if (_Py_RefTotal-- , --((PyObject*)(prod))->ob_refcnt != 0) { if (((PyObject*)prod)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2065, (PyObject *)(prod)); } else _Py_Dealloc((PyObject *)( prod)); } while (0); | ||
2066 | if (sum == NULL((void*)0)) | ||
2067 | return NULL((void*)0); | ||
2068 | |||
2069 | if (fracpart == 0.0) | ||
2070 | return sum; | ||
2071 | /* So far we've lost no information. Dealing with the | ||
2072 | * fractional part requires float arithmetic, and may | ||
2073 | * lose a little info. | ||
2074 | */ | ||
2075 | assert(PyLong_Check(factor))(__builtin_expect(!(((((((PyObject*)(factor))->ob_type))-> tp_flags & ((1L<<24))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2075, "PyLong_Check(factor)") : (void)0); | ||
2076 | dnum = PyLong_AsDouble(factor); | ||
2077 | |||
2078 | dnum *= fracpart; | ||
2079 | fracpart = modf(dnum, &intpart); | ||
2080 | x = PyLong_FromDouble(intpart); | ||
2081 | if (x == NULL((void*)0)) { | ||
2082 | Py_DECREF(sum)do { if (_Py_RefTotal-- , --((PyObject*)(sum))->ob_refcnt != 0) { if (((PyObject*)sum)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2082, (PyObject *)(sum)); } else _Py_Dealloc((PyObject *)(sum )); } while (0); | ||
2083 | return NULL((void*)0); | ||
2084 | } | ||
2085 | |||
2086 | y = PyNumber_Add(sum, x); | ||
2087 | Py_DECREF(sum)do { if (_Py_RefTotal-- , --((PyObject*)(sum))->ob_refcnt != 0) { if (((PyObject*)sum)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2087, (PyObject *)(sum)); } else _Py_Dealloc((PyObject *)(sum )); } while (0); | ||
2088 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2088, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
2089 | *leftover += fracpart; | ||
2090 | return y; | ||
2091 | } | ||
2092 | |||
2093 | PyErr_Format(PyExc_TypeError, | ||
2094 | "unsupported type for timedelta %s component: %s", | ||
2095 | tag, Py_TYPE(num)(((PyObject*)(num))->ob_type)->tp_name); | ||
2096 | return NULL((void*)0); | ||
2097 | } | ||
2098 | |||
2099 | static PyObject * | ||
2100 | delta_new(PyTypeObject *type, PyObject *args, PyObject *kw) | ||
2101 | { | ||
2102 | PyObject *self = NULL((void*)0); | ||
2103 | |||
2104 | /* Argument objects. */ | ||
2105 | PyObject *day = NULL((void*)0); | ||
2106 | PyObject *second = NULL((void*)0); | ||
2107 | PyObject *us = NULL((void*)0); | ||
2108 | PyObject *ms = NULL((void*)0); | ||
2109 | PyObject *minute = NULL((void*)0); | ||
2110 | PyObject *hour = NULL((void*)0); | ||
2111 | PyObject *week = NULL((void*)0); | ||
2112 | |||
2113 | PyObject *x = NULL((void*)0); /* running sum of microseconds */ | ||
2114 | PyObject *y = NULL((void*)0); /* temp sum of microseconds */ | ||
2115 | double leftover_us = 0.0; | ||
2116 | |||
2117 | static char *keywords[] = { | ||
2118 | "days", "seconds", "microseconds", "milliseconds", | ||
2119 | "minutes", "hours", "weeks", NULL((void*)0) | ||
2120 | }; | ||
2121 | |||
2122 | if (PyArg_ParseTupleAndKeywords(args, kw, "|OOOOOOO:__new__", | ||
2123 | keywords, | ||
2124 | &day, &second, &us, | ||
2125 | &ms, &minute, &hour, &week) == 0) | ||
2126 | goto Done; | ||
2127 | |||
2128 | x = PyLong_FromLong(0); | ||
2129 | if (x == NULL((void*)0)) | ||
2130 | goto Done; | ||
2131 | |||
2132 | #define CLEANUP \ | ||
2133 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2133, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); \ | ||
2134 | x = y; \ | ||
2135 | if (x == NULL((void*)0)) \ | ||
2136 | goto Done | ||
2137 | |||
2138 | if (us) { | ||
2139 | y = accum("microseconds", x, us, us_per_us, &leftover_us); | ||
2140 | CLEANUP; | ||
2141 | } | ||
2142 | if (ms) { | ||
2143 | y = accum("milliseconds", x, ms, us_per_ms, &leftover_us); | ||
2144 | CLEANUP; | ||
2145 | } | ||
2146 | if (second) { | ||
2147 | y = accum("seconds", x, second, us_per_second, &leftover_us); | ||
2148 | CLEANUP; | ||
2149 | } | ||
2150 | if (minute) { | ||
2151 | y = accum("minutes", x, minute, us_per_minute, &leftover_us); | ||
2152 | CLEANUP; | ||
2153 | } | ||
2154 | if (hour) { | ||
2155 | y = accum("hours", x, hour, us_per_hour, &leftover_us); | ||
2156 | CLEANUP; | ||
2157 | } | ||
2158 | if (day) { | ||
2159 | y = accum("days", x, day, us_per_day, &leftover_us); | ||
2160 | CLEANUP; | ||
2161 | } | ||
2162 | if (week) { | ||
2163 | y = accum("weeks", x, week, us_per_week, &leftover_us); | ||
2164 | CLEANUP; | ||
2165 | } | ||
2166 | if (leftover_us) { | ||
2167 | /* Round to nearest whole # of us, and add into x. */ | ||
2168 | PyObject *temp = PyLong_FromLong(round_to_long(leftover_us)); | ||
2169 | if (temp == NULL((void*)0)) { | ||
2170 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2170, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
2171 | goto Done; | ||
2172 | } | ||
2173 | y = PyNumber_Add(x, temp); | ||
2174 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2174, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
2175 | CLEANUP; | ||
2176 | } | ||
2177 | |||
2178 | self = microseconds_to_delta_ex(x, type); | ||
2179 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2179, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
2180 | Done: | ||
2181 | return self; | ||
2182 | |||
2183 | #undef CLEANUP | ||
2184 | } | ||
2185 | |||
2186 | static int | ||
2187 | delta_bool(PyDateTime_Delta *self) | ||
2188 | { | ||
2189 | return (GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days) != 0 | ||
2190 | || GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds) != 0 | ||
2191 | || GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds) != 0); | ||
2192 | } | ||
2193 | |||
2194 | static PyObject * | ||
2195 | delta_repr(PyDateTime_Delta *self) | ||
2196 | { | ||
2197 | if (GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds) != 0) | ||
2198 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d, %d)", | ||
2199 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name, | ||
2200 | GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days), | ||
2201 | GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds), | ||
2202 | GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds)); | ||
2203 | if (GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds) != 0) | ||
2204 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d)", | ||
2205 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name, | ||
2206 | GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days), | ||
2207 | GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds)); | ||
2208 | |||
2209 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d)", | ||
2210 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name, | ||
2211 | GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days)); | ||
2212 | } | ||
2213 | |||
2214 | static PyObject * | ||
2215 | delta_str(PyDateTime_Delta *self) | ||
2216 | { | ||
2217 | int us = GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds); | ||
2218 | int seconds = GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds); | ||
2219 | int minutes = divmod(seconds, 60, &seconds); | ||
2220 | int hours = divmod(minutes, 60, &minutes); | ||
2221 | int days = GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days); | ||
2222 | |||
2223 | if (days) { | ||
2224 | if (us) | ||
2225 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%d day%s, %d:%02d:%02d.%06d", | ||
2226 | days, (days == 1 || days == -1) ? "" : "s", | ||
2227 | hours, minutes, seconds, us); | ||
2228 | else | ||
2229 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%d day%s, %d:%02d:%02d", | ||
2230 | days, (days == 1 || days == -1) ? "" : "s", | ||
2231 | hours, minutes, seconds); | ||
2232 | } else { | ||
2233 | if (us) | ||
2234 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%d:%02d:%02d.%06d", | ||
2235 | hours, minutes, seconds, us); | ||
2236 | else | ||
2237 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%d:%02d:%02d", | ||
2238 | hours, minutes, seconds); | ||
2239 | } | ||
2240 | |||
2241 | } | ||
2242 | |||
2243 | /* Pickle support, a simple use of __reduce__. */ | ||
2244 | |||
2245 | /* __getstate__ isn't exposed */ | ||
2246 | static PyObject * | ||
2247 | delta_getstate(PyDateTime_Delta *self) | ||
2248 | { | ||
2249 | return Py_BuildValue("iii", GET_TD_DAYS(self)(((PyDateTime_Delta *)(self))->days), | ||
2250 | GET_TD_SECONDS(self)(((PyDateTime_Delta *)(self))->seconds), | ||
2251 | GET_TD_MICROSECONDS(self)(((PyDateTime_Delta *)(self))->microseconds)); | ||
2252 | } | ||
2253 | |||
2254 | static PyObject * | ||
2255 | delta_total_seconds(PyObject *self) | ||
2256 | { | ||
2257 | PyObject *total_seconds; | ||
2258 | PyObject *total_microseconds; | ||
2259 | PyObject *one_million; | ||
2260 | |||
2261 | total_microseconds = delta_to_microseconds((PyDateTime_Delta *)self); | ||
2262 | if (total_microseconds == NULL((void*)0)) | ||
2263 | return NULL((void*)0); | ||
2264 | |||
2265 | one_million = PyLong_FromLong(1000000L); | ||
2266 | if (one_million == NULL((void*)0)) { | ||
2267 | Py_DECREF(total_microseconds)do { if (_Py_RefTotal-- , --((PyObject*)(total_microseconds)) ->ob_refcnt != 0) { if (((PyObject*)total_microseconds)-> ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2267, (PyObject *)(total_microseconds)); } else _Py_Dealloc ((PyObject *)(total_microseconds)); } while (0); | ||
2268 | return NULL((void*)0); | ||
2269 | } | ||
2270 | |||
2271 | total_seconds = PyNumber_TrueDivide(total_microseconds, one_million); | ||
2272 | |||
2273 | Py_DECREF(total_microseconds)do { if (_Py_RefTotal-- , --((PyObject*)(total_microseconds)) ->ob_refcnt != 0) { if (((PyObject*)total_microseconds)-> ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2273, (PyObject *)(total_microseconds)); } else _Py_Dealloc ((PyObject *)(total_microseconds)); } while (0); | ||
2274 | Py_DECREF(one_million)do { if (_Py_RefTotal-- , --((PyObject*)(one_million))->ob_refcnt != 0) { if (((PyObject*)one_million)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2274, (PyObject *)(one_million)); } else _Py_Dealloc((PyObject *)(one_million)); } while (0); | ||
2275 | return total_seconds; | ||
2276 | } | ||
2277 | |||
2278 | static PyObject * | ||
2279 | delta_reduce(PyDateTime_Delta* self) | ||
2280 | { | ||
2281 | return Py_BuildValue("ON", Py_TYPE(self)(((PyObject*)(self))->ob_type), delta_getstate(self)); | ||
2282 | } | ||
2283 | |||
2284 | #define OFFSET(field)__builtin_offsetof(PyDateTime_Delta, field) offsetof(PyDateTime_Delta, field)__builtin_offsetof(PyDateTime_Delta, field) | ||
2285 | |||
2286 | static PyMemberDef delta_members[] = { | ||
2287 | |||
2288 | {"days", T_INT1, OFFSET(days)__builtin_offsetof(PyDateTime_Delta, days), READONLY1, | ||
2289 | PyDoc_STR("Number of days.")"Number of days."}, | ||
2290 | |||
2291 | {"seconds", T_INT1, OFFSET(seconds)__builtin_offsetof(PyDateTime_Delta, seconds), READONLY1, | ||
2292 | PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")"Number of seconds (>= 0 and less than 1 day)."}, | ||
2293 | |||
2294 | {"microseconds", T_INT1, OFFSET(microseconds)__builtin_offsetof(PyDateTime_Delta, microseconds), READONLY1, | ||
2295 | PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")"Number of microseconds (>= 0 and less than 1 second)."}, | ||
2296 | {NULL((void*)0)} | ||
2297 | }; | ||
2298 | |||
2299 | static PyMethodDef delta_methods[] = { | ||
2300 | {"total_seconds", (PyCFunction)delta_total_seconds, METH_NOARGS0x0004, | ||
2301 | PyDoc_STR("Total seconds in the duration.")"Total seconds in the duration."}, | ||
2302 | |||
2303 | {"__reduce__", (PyCFunction)delta_reduce, METH_NOARGS0x0004, | ||
2304 | PyDoc_STR("__reduce__() -> (cls, state)")"__reduce__() -> (cls, state)"}, | ||
2305 | |||
2306 | {NULL((void*)0), NULL((void*)0)}, | ||
2307 | }; | ||
2308 | |||
2309 | static char delta_doc[] = | ||
2310 | PyDoc_STR("Difference between two datetime values.")"Difference between two datetime values."; | ||
2311 | |||
2312 | static PyNumberMethods delta_as_number = { | ||
2313 | delta_add, /* nb_add */ | ||
2314 | delta_subtract, /* nb_subtract */ | ||
2315 | delta_multiply, /* nb_multiply */ | ||
2316 | delta_remainder, /* nb_remainder */ | ||
2317 | delta_divmod, /* nb_divmod */ | ||
2318 | 0, /* nb_power */ | ||
2319 | (unaryfunc)delta_negative, /* nb_negative */ | ||
2320 | (unaryfunc)delta_positive, /* nb_positive */ | ||
2321 | (unaryfunc)delta_abs, /* nb_absolute */ | ||
2322 | (inquiry)delta_bool, /* nb_bool */ | ||
2323 | 0, /*nb_invert*/ | ||
2324 | 0, /*nb_lshift*/ | ||
2325 | 0, /*nb_rshift*/ | ||
2326 | 0, /*nb_and*/ | ||
2327 | 0, /*nb_xor*/ | ||
2328 | 0, /*nb_or*/ | ||
2329 | 0, /*nb_int*/ | ||
2330 | 0, /*nb_reserved*/ | ||
2331 | 0, /*nb_float*/ | ||
2332 | 0, /*nb_inplace_add*/ | ||
2333 | 0, /*nb_inplace_subtract*/ | ||
2334 | 0, /*nb_inplace_multiply*/ | ||
2335 | 0, /*nb_inplace_remainder*/ | ||
2336 | 0, /*nb_inplace_power*/ | ||
2337 | 0, /*nb_inplace_lshift*/ | ||
2338 | 0, /*nb_inplace_rshift*/ | ||
2339 | 0, /*nb_inplace_and*/ | ||
2340 | 0, /*nb_inplace_xor*/ | ||
2341 | 0, /*nb_inplace_or*/ | ||
2342 | delta_divide, /* nb_floor_divide */ | ||
2343 | delta_truedivide, /* nb_true_divide */ | ||
2344 | 0, /* nb_inplace_floor_divide */ | ||
2345 | 0, /* nb_inplace_true_divide */ | ||
2346 | }; | ||
2347 | |||
2348 | static PyTypeObject PyDateTime_DeltaType = { | ||
2349 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
2350 | "datetime.timedelta", /* tp_name */ | ||
2351 | sizeof(PyDateTime_Delta), /* tp_basicsize */ | ||
2352 | 0, /* tp_itemsize */ | ||
2353 | 0, /* tp_dealloc */ | ||
2354 | 0, /* tp_print */ | ||
2355 | 0, /* tp_getattr */ | ||
2356 | 0, /* tp_setattr */ | ||
2357 | 0, /* tp_reserved */ | ||
2358 | (reprfunc)delta_repr, /* tp_repr */ | ||
2359 | &delta_as_number, /* tp_as_number */ | ||
2360 | 0, /* tp_as_sequence */ | ||
2361 | 0, /* tp_as_mapping */ | ||
2362 | (hashfunc)delta_hash, /* tp_hash */ | ||
2363 | 0, /* tp_call */ | ||
2364 | (reprfunc)delta_str, /* tp_str */ | ||
2365 | PyObject_GenericGetAttr, /* tp_getattro */ | ||
2366 | 0, /* tp_setattro */ | ||
2367 | 0, /* tp_as_buffer */ | ||
2368 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_BASETYPE(1L<<10), /* tp_flags */ | ||
2369 | delta_doc, /* tp_doc */ | ||
2370 | 0, /* tp_traverse */ | ||
2371 | 0, /* tp_clear */ | ||
2372 | delta_richcompare, /* tp_richcompare */ | ||
2373 | 0, /* tp_weaklistoffset */ | ||
2374 | 0, /* tp_iter */ | ||
2375 | 0, /* tp_iternext */ | ||
2376 | delta_methods, /* tp_methods */ | ||
2377 | delta_members, /* tp_members */ | ||
2378 | 0, /* tp_getset */ | ||
2379 | 0, /* tp_base */ | ||
2380 | 0, /* tp_dict */ | ||
2381 | 0, /* tp_descr_get */ | ||
2382 | 0, /* tp_descr_set */ | ||
2383 | 0, /* tp_dictoffset */ | ||
2384 | 0, /* tp_init */ | ||
2385 | 0, /* tp_alloc */ | ||
2386 | delta_new, /* tp_new */ | ||
2387 | 0, /* tp_free */ | ||
2388 | }; | ||
2389 | |||
2390 | /* | ||
2391 | * PyDateTime_Date implementation. | ||
2392 | */ | ||
2393 | |||
2394 | /* Accessor properties. */ | ||
2395 | |||
2396 | static PyObject * | ||
2397 | date_year(PyDateTime_Date *self, void *unused) | ||
2398 | { | ||
2399 | return PyLong_FromLong(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1])); | ||
2400 | } | ||
2401 | |||
2402 | static PyObject * | ||
2403 | date_month(PyDateTime_Date *self, void *unused) | ||
2404 | { | ||
2405 | return PyLong_FromLong(GET_MONTH(self)(((PyDateTime_Date*)self)->data[2])); | ||
2406 | } | ||
2407 | |||
2408 | static PyObject * | ||
2409 | date_day(PyDateTime_Date *self, void *unused) | ||
2410 | { | ||
2411 | return PyLong_FromLong(GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2412 | } | ||
2413 | |||
2414 | static PyGetSetDef date_getset[] = { | ||
2415 | {"year", (getter)date_year}, | ||
2416 | {"month", (getter)date_month}, | ||
2417 | {"day", (getter)date_day}, | ||
2418 | {NULL((void*)0)} | ||
2419 | }; | ||
2420 | |||
2421 | /* Constructors. */ | ||
2422 | |||
2423 | static char *date_kws[] = {"year", "month", "day", NULL((void*)0)}; | ||
2424 | |||
2425 | static PyObject * | ||
2426 | date_new(PyTypeObject *type, PyObject *args, PyObject *kw) | ||
2427 | { | ||
2428 | PyObject *self = NULL((void*)0); | ||
2429 | PyObject *state; | ||
2430 | int year; | ||
2431 | int month; | ||
2432 | int day; | ||
2433 | |||
2434 | /* Check for invocation from pickle with __getstate__ state */ | ||
2435 | if (PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) == 1 && | ||
2436 | PyBytes_Check(state = PyTuple_GET_ITEM(args, 0))((((((PyObject*)(state = (((PyTupleObject *)(args))->ob_item [0])))->ob_type))->tp_flags & ((1L<<27))) != 0 ) && | ||
2437 | PyBytes_GET_SIZE(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2437, "PyBytes_Check(state)") : (void)0),(((PyVarObject*)(state ))->ob_size)) == _PyDateTime_DATE_DATASIZE4 && | ||
2438 | MONTH_IS_SANE(PyBytes_AS_STRING(state)[2])((unsigned int)(((__builtin_expect(!(((((((PyObject*)(state)) ->ob_type))->tp_flags & ((1L<<27))) != 0)), 0 ) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2438, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval))[2]) - 1 < 12)) | ||
2439 | { | ||
2440 | PyDateTime_Date *me; | ||
2441 | |||
2442 | me = (PyDateTime_Date *) (type->tp_alloc(type, 0)); | ||
2443 | if (me != NULL((void*)0)) { | ||
2444 | char *pdata = PyBytes_AS_STRING(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2444, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval)); | ||
2445 | memcpy(me->data, pdata, _PyDateTime_DATE_DATASIZE)((__builtin_object_size (me->data, 0) != (size_t) -1) ? __builtin___memcpy_chk (me->data, pdata, 4, __builtin_object_size (me->data, 0 )) : __inline_memcpy_chk (me->data, pdata, 4)); | ||
2446 | me->hashcode = -1; | ||
2447 | } | ||
2448 | return (PyObject *)me; | ||
2449 | } | ||
2450 | |||
2451 | if (PyArg_ParseTupleAndKeywords(args, kw, "iii", date_kws, | ||
2452 | &year, &month, &day)) { | ||
2453 | if (check_date_args(year, month, day) < 0) | ||
2454 | return NULL((void*)0); | ||
2455 | self = new_date_ex(year, month, day, type); | ||
2456 | } | ||
2457 | return self; | ||
2458 | } | ||
2459 | |||
2460 | /* Return new date from localtime(t). */ | ||
2461 | static PyObject * | ||
2462 | date_local_from_time_t(PyObject *cls, double ts) | ||
2463 | { | ||
2464 | struct tm *tm; | ||
2465 | time_t t; | ||
2466 | PyObject *result = NULL((void*)0); | ||
2467 | |||
2468 | t = _PyTime_DoubleToTimet(ts); | ||
2469 | if (t == (time_t)-1 && PyErr_Occurred()) | ||
2470 | return NULL((void*)0); | ||
2471 | tm = localtime(&t); | ||
2472 | if (tm) | ||
2473 | result = PyObject_CallFunction(cls, "iii", | ||
2474 | tm->tm_year + 1900, | ||
2475 | tm->tm_mon + 1, | ||
2476 | tm->tm_mday); | ||
2477 | else | ||
2478 | PyErr_SetString(PyExc_ValueError, | ||
2479 | "timestamp out of range for " | ||
2480 | "platform localtime() function"); | ||
2481 | return result; | ||
2482 | } | ||
2483 | |||
2484 | /* Return new date from current time. | ||
2485 | * We say this is equivalent to fromtimestamp(time.time()), and the | ||
2486 | * only way to be sure of that is to *call* time.time(). That's not | ||
2487 | * generally the same as calling C's time. | ||
2488 | */ | ||
2489 | static PyObject * | ||
2490 | date_today(PyObject *cls, PyObject *dummy) | ||
2491 | { | ||
2492 | PyObject *time; | ||
2493 | PyObject *result; | ||
2494 | |||
2495 | time = time_time(); | ||
2496 | if (time == NULL((void*)0)) | ||
2497 | return NULL((void*)0); | ||
2498 | |||
2499 | /* Note well: today() is a class method, so this may not call | ||
2500 | * date.fromtimestamp. For example, it may call | ||
2501 | * datetime.fromtimestamp. That's why we need all the accuracy | ||
2502 | * time.time() delivers; if someone were gonzo about optimization, | ||
2503 | * date.today() could get away with plain C time(). | ||
2504 | */ | ||
2505 | result = PyObject_CallMethod(cls, "fromtimestamp", "O", time); | ||
2506 | Py_DECREF(time)do { if (_Py_RefTotal-- , --((PyObject*)(time))->ob_refcnt != 0) { if (((PyObject*)time)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2506, (PyObject *)(time)); } else _Py_Dealloc((PyObject *)( time)); } while (0); | ||
2507 | return result; | ||
2508 | } | ||
2509 | |||
2510 | /* Return new date from given timestamp (Python timestamp -- a double). */ | ||
2511 | static PyObject * | ||
2512 | date_fromtimestamp(PyObject *cls, PyObject *args) | ||
2513 | { | ||
2514 | double timestamp; | ||
2515 | PyObject *result = NULL((void*)0); | ||
2516 | |||
2517 | if (PyArg_ParseTuple(args, "d:fromtimestamp", ×tamp)) | ||
2518 | result = date_local_from_time_t(cls, timestamp); | ||
2519 | return result; | ||
2520 | } | ||
2521 | |||
2522 | /* Return new date from proleptic Gregorian ordinal. Raises ValueError if | ||
2523 | * the ordinal is out of range. | ||
2524 | */ | ||
2525 | static PyObject * | ||
2526 | date_fromordinal(PyObject *cls, PyObject *args) | ||
2527 | { | ||
2528 | PyObject *result = NULL((void*)0); | ||
2529 | int ordinal; | ||
2530 | |||
2531 | if (PyArg_ParseTuple(args, "i:fromordinal", &ordinal)) { | ||
2532 | int year; | ||
2533 | int month; | ||
2534 | int day; | ||
2535 | |||
2536 | if (ordinal < 1) | ||
2537 | PyErr_SetString(PyExc_ValueError, "ordinal must be " | ||
2538 | ">= 1"); | ||
2539 | else { | ||
2540 | ord_to_ymd(ordinal, &year, &month, &day); | ||
2541 | result = PyObject_CallFunction(cls, "iii", | ||
2542 | year, month, day); | ||
2543 | } | ||
2544 | } | ||
2545 | return result; | ||
2546 | } | ||
2547 | |||
2548 | /* | ||
2549 | * Date arithmetic. | ||
2550 | */ | ||
2551 | |||
2552 | /* date + timedelta -> date. If arg negate is true, subtract the timedelta | ||
2553 | * instead. | ||
2554 | */ | ||
2555 | static PyObject * | ||
2556 | add_date_timedelta(PyDateTime_Date *date, PyDateTime_Delta *delta, int negate) | ||
2557 | { | ||
2558 | PyObject *result = NULL((void*)0); | ||
2559 | int year = GET_YEAR(date)((((PyDateTime_Date*)date)->data[0] << 8) | ((PyDateTime_Date *)date)->data[1]); | ||
2560 | int month = GET_MONTH(date)(((PyDateTime_Date*)date)->data[2]); | ||
2561 | int deltadays = GET_TD_DAYS(delta)(((PyDateTime_Delta *)(delta))->days); | ||
2562 | /* C-level overflow is impossible because |deltadays| < 1e9. */ | ||
2563 | int day = GET_DAY(date)(((PyDateTime_Date*)date)->data[3]) + (negate ? -deltadays : deltadays); | ||
2564 | |||
2565 | if (normalize_date(&year, &month, &day) >= 0) | ||
2566 | result = new_date(year, month, day)new_date_ex(year, month, day, &PyDateTime_DateType); | ||
2567 | return result; | ||
2568 | } | ||
2569 | |||
2570 | static PyObject * | ||
2571 | date_add(PyObject *left, PyObject *right) | ||
2572 | { | ||
2573 | if (PyDateTime_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateTimeType))) || PyDateTime_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
2574 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
2575 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
2576 | } | ||
2577 | if (PyDate_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateType)))) { | ||
2578 | /* date + ??? */ | ||
2579 | if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) | ||
2580 | /* date + delta */ | ||
2581 | return add_date_timedelta((PyDateTime_Date *) left, | ||
2582 | (PyDateTime_Delta *) right, | ||
2583 | 0); | ||
2584 | } | ||
2585 | else { | ||
2586 | /* ??? + date | ||
2587 | * 'right' must be one of us, or we wouldn't have been called | ||
2588 | */ | ||
2589 | if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType)))) | ||
2590 | /* delta + date */ | ||
2591 | return add_date_timedelta((PyDateTime_Date *) right, | ||
2592 | (PyDateTime_Delta *) left, | ||
2593 | 0); | ||
2594 | } | ||
2595 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
2596 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
2597 | } | ||
2598 | |||
2599 | static PyObject * | ||
2600 | date_subtract(PyObject *left, PyObject *right) | ||
2601 | { | ||
2602 | if (PyDateTime_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateTimeType))) || PyDateTime_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
2603 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
2604 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
2605 | } | ||
2606 | if (PyDate_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateType)))) { | ||
2607 | if (PyDate_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DateType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DateType)))) { | ||
2608 | /* date - date */ | ||
2609 | int left_ord = ymd_to_ord(GET_YEAR(left)((((PyDateTime_Date*)left)->data[0] << 8) | ((PyDateTime_Date *)left)->data[1]), | ||
2610 | GET_MONTH(left)(((PyDateTime_Date*)left)->data[2]), | ||
2611 | GET_DAY(left)(((PyDateTime_Date*)left)->data[3])); | ||
2612 | int right_ord = ymd_to_ord(GET_YEAR(right)((((PyDateTime_Date*)right)->data[0] << 8) | ((PyDateTime_Date *)right)->data[1]), | ||
2613 | GET_MONTH(right)(((PyDateTime_Date*)right)->data[2]), | ||
2614 | GET_DAY(right)(((PyDateTime_Date*)right)->data[3])); | ||
2615 | return new_delta(left_ord - right_ord, 0, 0, 0)new_delta_ex(left_ord - right_ord, 0, 0, 0, &PyDateTime_DeltaType ); | ||
2616 | } | ||
2617 | if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
2618 | /* date - delta */ | ||
2619 | return add_date_timedelta((PyDateTime_Date *) left, | ||
2620 | (PyDateTime_Delta *) right, | ||
2621 | 1); | ||
2622 | } | ||
2623 | } | ||
2624 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
2625 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
2626 | } | ||
2627 | |||
2628 | |||
2629 | /* Various ways to turn a date into a string. */ | ||
2630 | |||
2631 | static PyObject * | ||
2632 | date_repr(PyDateTime_Date *self) | ||
2633 | { | ||
2634 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d, %d)", | ||
2635 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name, | ||
2636 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2637 | } | ||
2638 | |||
2639 | static PyObject * | ||
2640 | date_isoformat(PyDateTime_Date *self) | ||
2641 | { | ||
2642 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%04d-%02d-%02d", | ||
2643 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2644 | } | ||
2645 | |||
2646 | /* str() calls the appropriate isoformat() method. */ | ||
2647 | static PyObject * | ||
2648 | date_str(PyDateTime_Date *self) | ||
2649 | { | ||
2650 | return PyObject_CallMethod((PyObject *)self, "isoformat", "()"); | ||
2651 | } | ||
2652 | |||
2653 | |||
2654 | static PyObject * | ||
2655 | date_ctime(PyDateTime_Date *self) | ||
2656 | { | ||
2657 | return format_ctime(self, 0, 0, 0); | ||
2658 | } | ||
2659 | |||
2660 | static PyObject * | ||
2661 | date_strftime(PyDateTime_Date *self, PyObject *args, PyObject *kw) | ||
2662 | { | ||
2663 | /* This method can be inherited, and needs to call the | ||
2664 | * timetuple() method appropriate to self's class. | ||
2665 | */ | ||
2666 | PyObject *result; | ||
2667 | PyObject *tuple; | ||
2668 | PyObject *format; | ||
2669 | static char *keywords[] = {"format", NULL((void*)0)}; | ||
2670 | |||
2671 | if (! PyArg_ParseTupleAndKeywords(args, kw, "U:strftime", keywords, | ||
2672 | &format)) | ||
2673 | return NULL((void*)0); | ||
2674 | |||
2675 | tuple = PyObject_CallMethod((PyObject *)self, "timetuple", "()"); | ||
2676 | if (tuple == NULL((void*)0)) | ||
2677 | return NULL((void*)0); | ||
2678 | result = wrap_strftime((PyObject *)self, format, tuple, | ||
2679 | (PyObject *)self); | ||
2680 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2680, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
2681 | return result; | ||
2682 | } | ||
2683 | |||
2684 | static PyObject * | ||
2685 | date_format(PyDateTime_Date *self, PyObject *args) | ||
2686 | { | ||
2687 | PyObject *format; | ||
2688 | |||
2689 | if (!PyArg_ParseTuple(args, "U:__format__", &format)) | ||
2690 | return NULL((void*)0); | ||
2691 | |||
2692 | /* if the format is zero length, return str(self) */ | ||
2693 | if (PyUnicode_GetSizePyUnicodeUCS2_GetSize(format) == 0) | ||
2694 | return PyObject_Str((PyObject *)self); | ||
2695 | |||
2696 | return PyObject_CallMethod((PyObject *)self, "strftime", "O", format); | ||
2697 | } | ||
2698 | |||
2699 | /* ISO methods. */ | ||
2700 | |||
2701 | static PyObject * | ||
2702 | date_isoweekday(PyDateTime_Date *self) | ||
2703 | { | ||
2704 | int dow = weekday(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2705 | |||
2706 | return PyLong_FromLong(dow + 1); | ||
2707 | } | ||
2708 | |||
2709 | static PyObject * | ||
2710 | date_isocalendar(PyDateTime_Date *self) | ||
2711 | { | ||
2712 | int year = GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]); | ||
2713 | int week1_monday = iso_week1_monday(year); | ||
2714 | int today = ymd_to_ord(year, GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2715 | int week; | ||
2716 | int day; | ||
2717 | |||
2718 | week = divmod(today - week1_monday, 7, &day); | ||
2719 | if (week < 0) { | ||
2720 | --year; | ||
2721 | week1_monday = iso_week1_monday(year); | ||
2722 | week = divmod(today - week1_monday, 7, &day); | ||
2723 | } | ||
2724 | else if (week >= 52 && today >= iso_week1_monday(year + 1)) { | ||
2725 | ++year; | ||
2726 | week = 0; | ||
2727 | } | ||
2728 | return Py_BuildValue("iii", year, week + 1, day + 1); | ||
2729 | } | ||
2730 | |||
2731 | /* Miscellaneous methods. */ | ||
2732 | |||
2733 | static PyObject * | ||
2734 | date_richcompare(PyObject *self, PyObject *other, int op) | ||
2735 | { | ||
2736 | if (PyDate_Check(other)((((PyObject*)(other))->ob_type) == (&PyDateTime_DateType ) || PyType_IsSubtype((((PyObject*)(other))->ob_type), (& PyDateTime_DateType)))) { | ||
2737 | int diff = memcmp(((PyDateTime_Date *)self)->data, | ||
2738 | ((PyDateTime_Date *)other)->data, | ||
2739 | _PyDateTime_DATE_DATASIZE4); | ||
2740 | return diff_to_bool(diff, op); | ||
2741 | } | ||
2742 | else { | ||
2743 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
2744 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
2745 | } | ||
2746 | } | ||
2747 | |||
2748 | static PyObject * | ||
2749 | date_timetuple(PyDateTime_Date *self) | ||
2750 | { | ||
2751 | return build_struct_time(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), | ||
2752 | GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
2753 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), | ||
2754 | 0, 0, 0, -1); | ||
2755 | } | ||
2756 | |||
2757 | static PyObject * | ||
2758 | date_replace(PyDateTime_Date *self, PyObject *args, PyObject *kw) | ||
2759 | { | ||
2760 | PyObject *clone; | ||
2761 | PyObject *tuple; | ||
2762 | int year = GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]); | ||
2763 | int month = GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]); | ||
2764 | int day = GET_DAY(self)(((PyDateTime_Date*)self)->data[3]); | ||
2765 | |||
2766 | if (! PyArg_ParseTupleAndKeywords(args, kw, "|iii:replace", date_kws, | ||
2767 | &year, &month, &day)) | ||
2768 | return NULL((void*)0); | ||
2769 | tuple = Py_BuildValue("iii", year, month, day); | ||
2770 | if (tuple == NULL((void*)0)) | ||
2771 | return NULL((void*)0); | ||
2772 | clone = date_new(Py_TYPE(self)(((PyObject*)(self))->ob_type), tuple, NULL((void*)0)); | ||
2773 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 2773, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
2774 | return clone; | ||
2775 | } | ||
2776 | |||
2777 | /* | ||
2778 | Borrowed from stringobject.c, originally it was string_hash() | ||
2779 | */ | ||
2780 | static Py_hash_t | ||
2781 | generic_hash(unsigned char *data, int len) | ||
2782 | { | ||
2783 | register unsigned char *p; | ||
2784 | register Py_hash_t x; | ||
2785 | |||
2786 | p = (unsigned char *) data; | ||
2787 | x = *p << 7; | ||
2788 | while (--len >= 0) | ||
2789 | x = (1000003*x) ^ *p++; | ||
2790 | x ^= len; | ||
2791 | if (x == -1) | ||
2792 | x = -2; | ||
2793 | |||
2794 | return x; | ||
2795 | } | ||
2796 | |||
2797 | |||
2798 | static PyObject *date_getstate(PyDateTime_Date *self); | ||
2799 | |||
2800 | static Py_hash_t | ||
2801 | date_hash(PyDateTime_Date *self) | ||
2802 | { | ||
2803 | if (self->hashcode == -1) | ||
2804 | self->hashcode = generic_hash( | ||
2805 | (unsigned char *)self->data, _PyDateTime_DATE_DATASIZE4); | ||
2806 | |||
2807 | return self->hashcode; | ||
2808 | } | ||
2809 | |||
2810 | static PyObject * | ||
2811 | date_toordinal(PyDateTime_Date *self) | ||
2812 | { | ||
2813 | return PyLong_FromLong(ymd_to_ord(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
2814 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3]))); | ||
2815 | } | ||
2816 | |||
2817 | static PyObject * | ||
2818 | date_weekday(PyDateTime_Date *self) | ||
2819 | { | ||
2820 | int dow = weekday(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
2821 | |||
2822 | return PyLong_FromLong(dow); | ||
2823 | } | ||
2824 | |||
2825 | /* Pickle support, a simple use of __reduce__. */ | ||
2826 | |||
2827 | /* __getstate__ isn't exposed */ | ||
2828 | static PyObject * | ||
2829 | date_getstate(PyDateTime_Date *self) | ||
2830 | { | ||
2831 | PyObject* field; | ||
2832 | field = PyBytes_FromStringAndSize((char*)self->data, | ||
2833 | _PyDateTime_DATE_DATASIZE4); | ||
2834 | return Py_BuildValue("(N)", field); | ||
2835 | } | ||
2836 | |||
2837 | static PyObject * | ||
2838 | date_reduce(PyDateTime_Date *self, PyObject *arg) | ||
2839 | { | ||
2840 | return Py_BuildValue("(ON)", Py_TYPE(self)(((PyObject*)(self))->ob_type), date_getstate(self)); | ||
2841 | } | ||
2842 | |||
2843 | static PyMethodDef date_methods[] = { | ||
2844 | |||
2845 | /* Class methods: */ | ||
2846 | |||
2847 | {"fromtimestamp", (PyCFunction)date_fromtimestamp, METH_VARARGS0x0001 | | ||
2848 | METH_CLASS0x0010, | ||
2849 | PyDoc_STR("timestamp -> local date from a POSIX timestamp (like ""timestamp -> local date from a POSIX timestamp (like " "time.time())." | ||
2850 | "time.time()).")"timestamp -> local date from a POSIX timestamp (like " "time.time())."}, | ||
2851 | |||
2852 | {"fromordinal", (PyCFunction)date_fromordinal, METH_VARARGS0x0001 | | ||
2853 | METH_CLASS0x0010, | ||
2854 | PyDoc_STR("int -> date corresponding to a proleptic Gregorian ""int -> date corresponding to a proleptic Gregorian " "ordinal." | ||
2855 | "ordinal.")"int -> date corresponding to a proleptic Gregorian " "ordinal."}, | ||
2856 | |||
2857 | {"today", (PyCFunction)date_today, METH_NOARGS0x0004 | METH_CLASS0x0010, | ||
2858 | PyDoc_STR("Current date or datetime: same as ""Current date or datetime: same as " "self.__class__.fromtimestamp(time.time())." | ||
2859 | "self.__class__.fromtimestamp(time.time()).")"Current date or datetime: same as " "self.__class__.fromtimestamp(time.time())."}, | ||
2860 | |||
2861 | /* Instance methods: */ | ||
2862 | |||
2863 | {"ctime", (PyCFunction)date_ctime, METH_NOARGS0x0004, | ||
2864 | PyDoc_STR("Return ctime() style string.")"Return ctime() style string."}, | ||
2865 | |||
2866 | {"strftime", (PyCFunction)date_strftime, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
2867 | PyDoc_STR("format -> strftime() style string.")"format -> strftime() style string."}, | ||
2868 | |||
2869 | {"__format__", (PyCFunction)date_format, METH_VARARGS0x0001, | ||
2870 | PyDoc_STR("Formats self with strftime.")"Formats self with strftime."}, | ||
2871 | |||
2872 | {"timetuple", (PyCFunction)date_timetuple, METH_NOARGS0x0004, | ||
2873 | PyDoc_STR("Return time tuple, compatible with time.localtime().")"Return time tuple, compatible with time.localtime()."}, | ||
2874 | |||
2875 | {"isocalendar", (PyCFunction)date_isocalendar, METH_NOARGS0x0004, | ||
2876 | PyDoc_STR("Return a 3-tuple containing ISO year, week number, and ""Return a 3-tuple containing ISO year, week number, and " "weekday." | ||
2877 | "weekday.")"Return a 3-tuple containing ISO year, week number, and " "weekday."}, | ||
2878 | |||
2879 | {"isoformat", (PyCFunction)date_isoformat, METH_NOARGS0x0004, | ||
2880 | PyDoc_STR("Return string in ISO 8601 format, YYYY-MM-DD.")"Return string in ISO 8601 format, YYYY-MM-DD."}, | ||
2881 | |||
2882 | {"isoweekday", (PyCFunction)date_isoweekday, METH_NOARGS0x0004, | ||
2883 | PyDoc_STR("Return the day of the week represented by the date.\n""Return the day of the week represented by the date.\n" "Monday == 1 ... Sunday == 7" | ||
2884 | "Monday == 1 ... Sunday == 7")"Return the day of the week represented by the date.\n" "Monday == 1 ... Sunday == 7"}, | ||
2885 | |||
2886 | {"toordinal", (PyCFunction)date_toordinal, METH_NOARGS0x0004, | ||
2887 | PyDoc_STR("Return proleptic Gregorian ordinal. January 1 of year ""Return proleptic Gregorian ordinal. January 1 of year " "1 is day 1." | ||
2888 | "1 is day 1.")"Return proleptic Gregorian ordinal. January 1 of year " "1 is day 1."}, | ||
2889 | |||
2890 | {"weekday", (PyCFunction)date_weekday, METH_NOARGS0x0004, | ||
2891 | PyDoc_STR("Return the day of the week represented by the date.\n""Return the day of the week represented by the date.\n" "Monday == 0 ... Sunday == 6" | ||
2892 | "Monday == 0 ... Sunday == 6")"Return the day of the week represented by the date.\n" "Monday == 0 ... Sunday == 6"}, | ||
2893 | |||
2894 | {"replace", (PyCFunction)date_replace, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
2895 | PyDoc_STR("Return date with new specified fields.")"Return date with new specified fields."}, | ||
2896 | |||
2897 | {"__reduce__", (PyCFunction)date_reduce, METH_NOARGS0x0004, | ||
2898 | PyDoc_STR("__reduce__() -> (cls, state)")"__reduce__() -> (cls, state)"}, | ||
2899 | |||
2900 | {NULL((void*)0), NULL((void*)0)} | ||
2901 | }; | ||
2902 | |||
2903 | static char date_doc[] = | ||
2904 | PyDoc_STR("date(year, month, day) --> date object")"date(year, month, day) --> date object"; | ||
2905 | |||
2906 | static PyNumberMethods date_as_number = { | ||
2907 | date_add, /* nb_add */ | ||
2908 | date_subtract, /* nb_subtract */ | ||
2909 | 0, /* nb_multiply */ | ||
2910 | 0, /* nb_remainder */ | ||
2911 | 0, /* nb_divmod */ | ||
2912 | 0, /* nb_power */ | ||
2913 | 0, /* nb_negative */ | ||
2914 | 0, /* nb_positive */ | ||
2915 | 0, /* nb_absolute */ | ||
2916 | 0, /* nb_bool */ | ||
2917 | }; | ||
2918 | |||
2919 | static PyTypeObject PyDateTime_DateType = { | ||
2920 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
2921 | "datetime.date", /* tp_name */ | ||
2922 | sizeof(PyDateTime_Date), /* tp_basicsize */ | ||
2923 | 0, /* tp_itemsize */ | ||
2924 | 0, /* tp_dealloc */ | ||
2925 | 0, /* tp_print */ | ||
2926 | 0, /* tp_getattr */ | ||
2927 | 0, /* tp_setattr */ | ||
2928 | 0, /* tp_reserved */ | ||
2929 | (reprfunc)date_repr, /* tp_repr */ | ||
2930 | &date_as_number, /* tp_as_number */ | ||
2931 | 0, /* tp_as_sequence */ | ||
2932 | 0, /* tp_as_mapping */ | ||
2933 | (hashfunc)date_hash, /* tp_hash */ | ||
2934 | 0, /* tp_call */ | ||
2935 | (reprfunc)date_str, /* tp_str */ | ||
2936 | PyObject_GenericGetAttr, /* tp_getattro */ | ||
2937 | 0, /* tp_setattro */ | ||
2938 | 0, /* tp_as_buffer */ | ||
2939 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_BASETYPE(1L<<10), /* tp_flags */ | ||
2940 | date_doc, /* tp_doc */ | ||
2941 | 0, /* tp_traverse */ | ||
2942 | 0, /* tp_clear */ | ||
2943 | date_richcompare, /* tp_richcompare */ | ||
2944 | 0, /* tp_weaklistoffset */ | ||
2945 | 0, /* tp_iter */ | ||
2946 | 0, /* tp_iternext */ | ||
2947 | date_methods, /* tp_methods */ | ||
2948 | 0, /* tp_members */ | ||
2949 | date_getset, /* tp_getset */ | ||
2950 | 0, /* tp_base */ | ||
2951 | 0, /* tp_dict */ | ||
2952 | 0, /* tp_descr_get */ | ||
2953 | 0, /* tp_descr_set */ | ||
2954 | 0, /* tp_dictoffset */ | ||
2955 | 0, /* tp_init */ | ||
2956 | 0, /* tp_alloc */ | ||
2957 | date_new, /* tp_new */ | ||
2958 | 0, /* tp_free */ | ||
2959 | }; | ||
2960 | |||
2961 | /* | ||
2962 | * PyDateTime_TZInfo implementation. | ||
2963 | */ | ||
2964 | |||
2965 | /* This is a pure abstract base class, so doesn't do anything beyond | ||
2966 | * raising NotImplemented exceptions. Real tzinfo classes need | ||
2967 | * to derive from this. This is mostly for clarity, and for efficiency in | ||
2968 | * datetime and time constructors (their tzinfo arguments need to | ||
2969 | * be subclasses of this tzinfo class, which is easy and quick to check). | ||
2970 | * | ||
2971 | * Note: For reasons having to do with pickling of subclasses, we have | ||
2972 | * to allow tzinfo objects to be instantiated. This wasn't an issue | ||
2973 | * in the Python implementation (__init__() could raise NotImplementedError | ||
2974 | * there without ill effect), but doing so in the C implementation hit a | ||
2975 | * brick wall. | ||
2976 | */ | ||
2977 | |||
2978 | static PyObject * | ||
2979 | tzinfo_nogo(const char* methodname) | ||
2980 | { | ||
2981 | PyErr_Format(PyExc_NotImplementedError, | ||
2982 | "a tzinfo subclass must implement %s()", | ||
2983 | methodname); | ||
2984 | return NULL((void*)0); | ||
2985 | } | ||
2986 | |||
2987 | /* Methods. A subclass must implement these. */ | ||
2988 | |||
2989 | static PyObject * | ||
2990 | tzinfo_tzname(PyDateTime_TZInfo *self, PyObject *dt) | ||
2991 | { | ||
2992 | return tzinfo_nogo("tzname"); | ||
2993 | } | ||
2994 | |||
2995 | static PyObject * | ||
2996 | tzinfo_utcoffset(PyDateTime_TZInfo *self, PyObject *dt) | ||
2997 | { | ||
2998 | return tzinfo_nogo("utcoffset"); | ||
2999 | } | ||
3000 | |||
3001 | static PyObject * | ||
3002 | tzinfo_dst(PyDateTime_TZInfo *self, PyObject *dt) | ||
3003 | { | ||
3004 | return tzinfo_nogo("dst"); | ||
3005 | } | ||
3006 | |||
3007 | |||
3008 | static PyObject *add_datetime_timedelta(PyDateTime_DateTime *date, | ||
3009 | PyDateTime_Delta *delta, | ||
3010 | int factor); | ||
3011 | static PyObject *datetime_utcoffset(PyObject *self, PyObject *); | ||
3012 | static PyObject *datetime_dst(PyObject *self, PyObject *); | ||
3013 | |||
3014 | static PyObject * | ||
3015 | tzinfo_fromutc(PyDateTime_TZInfo *self, PyObject *dt) | ||
3016 | { | ||
3017 | PyObject *result = NULL((void*)0); | ||
3018 | PyObject *off = NULL((void*)0), *dst = NULL((void*)0); | ||
3019 | PyDateTime_Delta *delta = NULL((void*)0); | ||
3020 | |||
3021 | if (!PyDateTime_Check(dt)((((PyObject*)(dt))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(dt))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
3022 | PyErr_SetString(PyExc_TypeError, | ||
3023 | "fromutc: argument must be a datetime"); | ||
3024 | return NULL((void*)0); | ||
3025 | } | ||
3026 | if (GET_DT_TZINFO(dt)((((_PyDateTime_BaseTZInfo *)(dt))->hastzinfo) ? ((PyDateTime_DateTime *)(dt))->tzinfo : (&_Py_NoneStruct)) != (PyObject *)self) { | ||
3027 | PyErr_SetString(PyExc_ValueError, "fromutc: dt.tzinfo " | ||
3028 | "is not self"); | ||
3029 | return NULL((void*)0); | ||
3030 | } | ||
3031 | |||
3032 | off = datetime_utcoffset(dt, NULL((void*)0)); | ||
3033 | if (off == NULL((void*)0)) | ||
3034 | return NULL((void*)0); | ||
3035 | if (off == Py_None(&_Py_NoneStruct)) { | ||
3036 | PyErr_SetString(PyExc_ValueError, "fromutc: non-None " | ||
3037 | "utcoffset() result required"); | ||
3038 | goto Fail; | ||
3039 | } | ||
3040 | |||
3041 | dst = datetime_dst(dt, NULL((void*)0)); | ||
3042 | if (dst == NULL((void*)0)) | ||
3043 | goto Fail; | ||
3044 | if (dst == Py_None(&_Py_NoneStruct)) { | ||
3045 | PyErr_SetString(PyExc_ValueError, "fromutc: non-None " | ||
3046 | "dst() result required"); | ||
3047 | goto Fail; | ||
3048 | } | ||
3049 | |||
3050 | delta = (PyDateTime_Delta *)delta_subtract(off, dst); | ||
3051 | if (delta == NULL((void*)0)) | ||
3052 | goto Fail; | ||
3053 | result = add_datetime_timedelta((PyDateTime_DateTime *)dt, delta, 1); | ||
3054 | if (result == NULL((void*)0)) | ||
3055 | goto Fail; | ||
3056 | |||
3057 | Py_DECREF(dst)do { if (_Py_RefTotal-- , --((PyObject*)(dst))->ob_refcnt != 0) { if (((PyObject*)dst)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3057, (PyObject *)(dst)); } else _Py_Dealloc((PyObject *)(dst )); } while (0); | ||
3058 | dst = call_dst(GET_DT_TZINFO(dt)((((_PyDateTime_BaseTZInfo *)(dt))->hastzinfo) ? ((PyDateTime_DateTime *)(dt))->tzinfo : (&_Py_NoneStruct)), result); | ||
3059 | if (dst == NULL((void*)0)) | ||
3060 | goto Fail; | ||
3061 | if (dst == Py_None(&_Py_NoneStruct)) | ||
3062 | goto Inconsistent; | ||
3063 | if (delta_bool(delta) != 0) { | ||
3064 | PyObject *temp = result; | ||
3065 | result = add_datetime_timedelta((PyDateTime_DateTime *)result, | ||
3066 | (PyDateTime_Delta *)dst, 1); | ||
3067 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3067, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
3068 | if (result == NULL((void*)0)) | ||
3069 | goto Fail; | ||
3070 | } | ||
3071 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3071, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
3072 | Py_DECREF(dst)do { if (_Py_RefTotal-- , --((PyObject*)(dst))->ob_refcnt != 0) { if (((PyObject*)dst)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3072, (PyObject *)(dst)); } else _Py_Dealloc((PyObject *)(dst )); } while (0); | ||
3073 | Py_DECREF(off)do { if (_Py_RefTotal-- , --((PyObject*)(off))->ob_refcnt != 0) { if (((PyObject*)off)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3073, (PyObject *)(off)); } else _Py_Dealloc((PyObject *)(off )); } while (0); | ||
3074 | return result; | ||
3075 | |||
3076 | Inconsistent: | ||
3077 | PyErr_SetString(PyExc_ValueError, "fromutc: tz.dst() gave" | ||
3078 | "inconsistent results; cannot convert"); | ||
3079 | |||
3080 | /* fall thru to failure */ | ||
3081 | Fail: | ||
3082 | Py_XDECREF(off)do { if ((off) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(off))->ob_refcnt != 0) { if (((PyObject*)off )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3082, (PyObject *)(off)); } else _Py_Dealloc((PyObject *)(off )); } while (0); } while (0); | ||
3083 | Py_XDECREF(dst)do { if ((dst) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(dst))->ob_refcnt != 0) { if (((PyObject*)dst )->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3083, (PyObject *)(dst)); } else _Py_Dealloc((PyObject *)(dst )); } while (0); } while (0); | ||
3084 | Py_XDECREF(delta)do { if ((delta) == ((void*)0)) ; else do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject *)delta)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3084, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); } while (0); | ||
3085 | Py_XDECREF(result)do { if ((result) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject *)result)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3085, (PyObject *)(result)); } else _Py_Dealloc((PyObject * )(result)); } while (0); } while (0); | ||
3086 | return NULL((void*)0); | ||
3087 | } | ||
3088 | |||
3089 | /* | ||
3090 | * Pickle support. This is solely so that tzinfo subclasses can use | ||
3091 | * pickling -- tzinfo itself is supposed to be uninstantiable. | ||
3092 | */ | ||
3093 | |||
3094 | static PyObject * | ||
3095 | tzinfo_reduce(PyObject *self) | ||
3096 | { | ||
3097 | PyObject *args, *state, *tmp; | ||
3098 | PyObject *getinitargs, *getstate; | ||
3099 | |||
3100 | tmp = PyTuple_New(0); | ||
3101 | if (tmp == NULL((void*)0)) | ||
3102 | return NULL((void*)0); | ||
3103 | |||
3104 | getinitargs = PyObject_GetAttrString(self, "__getinitargs__"); | ||
3105 | if (getinitargs != NULL((void*)0)) { | ||
3106 | args = PyObject_CallObject(getinitargs, tmp); | ||
3107 | Py_DECREF(getinitargs)do { if (_Py_RefTotal-- , --((PyObject*)(getinitargs))->ob_refcnt != 0) { if (((PyObject*)getinitargs)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3107, (PyObject *)(getinitargs)); } else _Py_Dealloc((PyObject *)(getinitargs)); } while (0); | ||
3108 | if (args == NULL((void*)0)) { | ||
3109 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3109, (PyObject *)(tmp)); } else _Py_Dealloc((PyObject *)(tmp )); } while (0); | ||
3110 | return NULL((void*)0); | ||
3111 | } | ||
3112 | } | ||
3113 | else { | ||
3114 | PyErr_Clear(); | ||
3115 | args = tmp; | ||
3116 | Py_INCREF(args)( _Py_RefTotal++ , ((PyObject*)(args))->ob_refcnt++); | ||
3117 | } | ||
3118 | |||
3119 | getstate = PyObject_GetAttrString(self, "__getstate__"); | ||
3120 | if (getstate != NULL((void*)0)) { | ||
3121 | state = PyObject_CallObject(getstate, tmp); | ||
3122 | Py_DECREF(getstate)do { if (_Py_RefTotal-- , --((PyObject*)(getstate))->ob_refcnt != 0) { if (((PyObject*)getstate)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3122, (PyObject *)(getstate)); } else _Py_Dealloc((PyObject *)(getstate)); } while (0); | ||
3123 | if (state == NULL((void*)0)) { | ||
3124 | Py_DECREF(args)do { if (_Py_RefTotal-- , --((PyObject*)(args))->ob_refcnt != 0) { if (((PyObject*)args)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3124, (PyObject *)(args)); } else _Py_Dealloc((PyObject *)( args)); } while (0); | ||
3125 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3125, (PyObject *)(tmp)); } else _Py_Dealloc((PyObject *)(tmp )); } while (0); | ||
3126 | return NULL((void*)0); | ||
3127 | } | ||
3128 | } | ||
3129 | else { | ||
3130 | PyObject **dictptr; | ||
3131 | PyErr_Clear(); | ||
3132 | state = Py_None(&_Py_NoneStruct); | ||
3133 | dictptr = _PyObject_GetDictPtr(self); | ||
3134 | if (dictptr && *dictptr && PyDict_Size(*dictptr)) | ||
3135 | state = *dictptr; | ||
3136 | Py_INCREF(state)( _Py_RefTotal++ , ((PyObject*)(state))->ob_refcnt++); | ||
3137 | } | ||
3138 | |||
3139 | Py_DECREF(tmp)do { if (_Py_RefTotal-- , --((PyObject*)(tmp))->ob_refcnt != 0) { if (((PyObject*)tmp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3139, (PyObject *)(tmp)); } else _Py_Dealloc((PyObject *)(tmp )); } while (0); | ||
3140 | |||
3141 | if (state == Py_None(&_Py_NoneStruct)) { | ||
3142 | Py_DECREF(state)do { if (_Py_RefTotal-- , --((PyObject*)(state))->ob_refcnt != 0) { if (((PyObject*)state)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3142, (PyObject *)(state)); } else _Py_Dealloc((PyObject *) (state)); } while (0); | ||
3143 | return Py_BuildValue("(ON)", Py_TYPE(self)(((PyObject*)(self))->ob_type), args); | ||
3144 | } | ||
3145 | else | ||
3146 | return Py_BuildValue("(ONN)", Py_TYPE(self)(((PyObject*)(self))->ob_type), args, state); | ||
3147 | } | ||
3148 | |||
3149 | static PyMethodDef tzinfo_methods[] = { | ||
3150 | |||
3151 | {"tzname", (PyCFunction)tzinfo_tzname, METH_O0x0008, | ||
3152 | PyDoc_STR("datetime -> string name of time zone.")"datetime -> string name of time zone."}, | ||
3153 | |||
3154 | {"utcoffset", (PyCFunction)tzinfo_utcoffset, METH_O0x0008, | ||
3155 | PyDoc_STR("datetime -> timedelta showing offset from UTC, negative ""datetime -> timedelta showing offset from UTC, negative " "values indicating West of UTC" | ||
3156 | "values indicating West of UTC")"datetime -> timedelta showing offset from UTC, negative " "values indicating West of UTC"}, | ||
3157 | |||
3158 | {"dst", (PyCFunction)tzinfo_dst, METH_O0x0008, | ||
3159 | PyDoc_STR("datetime -> DST offset in minutes east of UTC.")"datetime -> DST offset in minutes east of UTC."}, | ||
3160 | |||
3161 | {"fromutc", (PyCFunction)tzinfo_fromutc, METH_O0x0008, | ||
3162 | PyDoc_STR("datetime in UTC -> datetime in local time.")"datetime in UTC -> datetime in local time."}, | ||
3163 | |||
3164 | {"__reduce__", (PyCFunction)tzinfo_reduce, METH_NOARGS0x0004, | ||
3165 | PyDoc_STR("-> (cls, state)")"-> (cls, state)"}, | ||
3166 | |||
3167 | {NULL((void*)0), NULL((void*)0)} | ||
3168 | }; | ||
3169 | |||
3170 | static char tzinfo_doc[] = | ||
3171 | PyDoc_STR("Abstract base class for time zone info objects.")"Abstract base class for time zone info objects."; | ||
3172 | |||
3173 | static PyTypeObject PyDateTime_TZInfoType = { | ||
3174 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
3175 | "datetime.tzinfo", /* tp_name */ | ||
3176 | sizeof(PyDateTime_TZInfo), /* tp_basicsize */ | ||
3177 | 0, /* tp_itemsize */ | ||
3178 | 0, /* tp_dealloc */ | ||
3179 | 0, /* tp_print */ | ||
3180 | 0, /* tp_getattr */ | ||
3181 | 0, /* tp_setattr */ | ||
3182 | 0, /* tp_reserved */ | ||
3183 | 0, /* tp_repr */ | ||
3184 | 0, /* tp_as_number */ | ||
3185 | 0, /* tp_as_sequence */ | ||
3186 | 0, /* tp_as_mapping */ | ||
3187 | 0, /* tp_hash */ | ||
3188 | 0, /* tp_call */ | ||
3189 | 0, /* tp_str */ | ||
3190 | PyObject_GenericGetAttr, /* tp_getattro */ | ||
3191 | 0, /* tp_setattro */ | ||
3192 | 0, /* tp_as_buffer */ | ||
3193 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_BASETYPE(1L<<10), /* tp_flags */ | ||
3194 | tzinfo_doc, /* tp_doc */ | ||
3195 | 0, /* tp_traverse */ | ||
3196 | 0, /* tp_clear */ | ||
3197 | 0, /* tp_richcompare */ | ||
3198 | 0, /* tp_weaklistoffset */ | ||
3199 | 0, /* tp_iter */ | ||
3200 | 0, /* tp_iternext */ | ||
3201 | tzinfo_methods, /* tp_methods */ | ||
3202 | 0, /* tp_members */ | ||
3203 | 0, /* tp_getset */ | ||
3204 | 0, /* tp_base */ | ||
3205 | 0, /* tp_dict */ | ||
3206 | 0, /* tp_descr_get */ | ||
3207 | 0, /* tp_descr_set */ | ||
3208 | 0, /* tp_dictoffset */ | ||
3209 | 0, /* tp_init */ | ||
3210 | 0, /* tp_alloc */ | ||
3211 | PyType_GenericNew, /* tp_new */ | ||
3212 | 0, /* tp_free */ | ||
3213 | }; | ||
3214 | |||
3215 | static char *timezone_kws[] = {"offset", "name", NULL((void*)0)}; | ||
3216 | |||
3217 | static PyObject * | ||
3218 | timezone_new(PyTypeObject *type, PyObject *args, PyObject *kw) | ||
3219 | { | ||
3220 | PyObject *offset; | ||
3221 | PyObject *name = NULL((void*)0); | ||
3222 | if (PyArg_ParseTupleAndKeywords(args, kw, "O!|O!:timezone", timezone_kws, | ||
3223 | &PyDateTime_DeltaType, &offset, | ||
3224 | &PyUnicode_Type, &name)) | ||
3225 | return new_timezone(offset, name); | ||
3226 | |||
3227 | return NULL((void*)0); | ||
3228 | } | ||
3229 | |||
3230 | static void | ||
3231 | timezone_dealloc(PyDateTime_TimeZone *self) | ||
3232 | { | ||
3233 | Py_CLEAR(self->offset)do { if (self->offset) { PyObject *_py_tmp = (PyObject *)( self->offset); (self->offset) = ((void*)0); do { if (_Py_RefTotal -- , --((PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject *)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3233, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject * )(_py_tmp)); } while (0); } } while (0); | ||
3234 | Py_CLEAR(self->name)do { if (self->name) { PyObject *_py_tmp = (PyObject *)(self ->name); (self->name) = ((void*)0); do { if (_Py_RefTotal -- , --((PyObject*)(_py_tmp))->ob_refcnt != 0) { if (((PyObject *)_py_tmp)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3234, (PyObject *)(_py_tmp)); } else _Py_Dealloc((PyObject * )(_py_tmp)); } while (0); } } while (0); | ||
3235 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject *)self); | ||
3236 | } | ||
3237 | |||
3238 | static PyObject * | ||
3239 | timezone_richcompare(PyDateTime_TimeZone *self, | ||
3240 | PyDateTime_TimeZone *other, int op) | ||
3241 | { | ||
3242 | if (op != Py_EQ2 && op != Py_NE3) { | ||
3243 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
3244 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
3245 | } | ||
3246 | return delta_richcompare(self->offset, other->offset, op); | ||
3247 | } | ||
3248 | |||
3249 | static Py_hash_t | ||
3250 | timezone_hash(PyDateTime_TimeZone *self) | ||
3251 | { | ||
3252 | return delta_hash((PyDateTime_Delta *)self->offset); | ||
3253 | } | ||
3254 | |||
3255 | /* Check argument type passed to tzname, utcoffset, or dst methods. | ||
3256 | Returns 0 for good argument. Returns -1 and sets exception info | ||
3257 | otherwise. | ||
3258 | */ | ||
3259 | static int | ||
3260 | _timezone_check_argument(PyObject *dt, const char *meth) | ||
3261 | { | ||
3262 | if (dt == Py_None(&_Py_NoneStruct) || PyDateTime_Check(dt)((((PyObject*)(dt))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(dt))->ob_type), (& PyDateTime_DateTimeType)))) | ||
3263 | return 0; | ||
3264 | PyErr_Format(PyExc_TypeError, "%s(dt) argument must be a datetime instance" | ||
3265 | " or None, not %.200s", meth, Py_TYPE(dt)(((PyObject*)(dt))->ob_type)->tp_name); | ||
3266 | return -1; | ||
3267 | } | ||
3268 | |||
3269 | static PyObject * | ||
3270 | timezone_repr(PyDateTime_TimeZone *self) | ||
3271 | { | ||
3272 | /* Note that although timezone is not subclassable, it is convenient | ||
3273 | to use Py_TYPE(self)->tp_name here. */ | ||
3274 | const char *type_name = Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name; | ||
3275 | |||
3276 | if (((PyObject *)self) == PyDateTime_TimeZone_UTC) | ||
3277 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s.utc", type_name); | ||
3278 | |||
3279 | if (self->name == NULL((void*)0)) | ||
3280 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%R)", type_name, self->offset); | ||
3281 | |||
3282 | return PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%R, %R)", type_name, self->offset, | ||
3283 | self->name); | ||
3284 | } | ||
3285 | |||
3286 | |||
3287 | static PyObject * | ||
3288 | timezone_str(PyDateTime_TimeZone *self) | ||
3289 | { | ||
3290 | char buf[10]; | ||
3291 | int hours, minutes, seconds; | ||
3292 | PyObject *offset; | ||
3293 | char sign; | ||
3294 | |||
3295 | if (self->name != NULL((void*)0)) { | ||
3296 | Py_INCREF(self->name)( _Py_RefTotal++ , ((PyObject*)(self->name))->ob_refcnt ++); | ||
3297 | return self->name; | ||
3298 | } | ||
3299 | /* Offset is normalized, so it is negative if days < 0 */ | ||
3300 | if (GET_TD_DAYS(self->offset)(((PyDateTime_Delta *)(self->offset))->days) < 0) { | ||
3301 | sign = '-'; | ||
3302 | offset = delta_negative((PyDateTime_Delta *)self->offset); | ||
3303 | if (offset == NULL((void*)0)) | ||
3304 | return NULL((void*)0); | ||
3305 | } | ||
3306 | else { | ||
3307 | sign = '+'; | ||
3308 | offset = self->offset; | ||
3309 | Py_INCREF(offset)( _Py_RefTotal++ , ((PyObject*)(offset))->ob_refcnt++); | ||
3310 | } | ||
3311 | /* Offset is not negative here. */ | ||
3312 | seconds = GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds); | ||
3313 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3313, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
3314 | minutes = divmod(seconds, 60, &seconds); | ||
3315 | hours = divmod(minutes, 60, &minutes); | ||
3316 | assert(seconds == 0)(__builtin_expect(!(seconds == 0), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3316, "seconds == 0") : (void)0); | ||
3317 | /* XXX ignore sub-minute data, curently not allowed. */ | ||
3318 | PyOS_snprintf(buf, sizeof(buf), "UTC%c%02d:%02d", sign, hours, minutes); | ||
3319 | |||
3320 | return PyUnicode_FromStringPyUnicodeUCS2_FromString(buf); | ||
3321 | } | ||
3322 | |||
3323 | static PyObject * | ||
3324 | timezone_tzname(PyDateTime_TimeZone *self, PyObject *dt) | ||
3325 | { | ||
3326 | if (_timezone_check_argument(dt, "tzname") == -1) | ||
3327 | return NULL((void*)0); | ||
3328 | |||
3329 | return timezone_str(self); | ||
3330 | } | ||
3331 | |||
3332 | static PyObject * | ||
3333 | timezone_utcoffset(PyDateTime_TimeZone *self, PyObject *dt) | ||
3334 | { | ||
3335 | if (_timezone_check_argument(dt, "utcoffset") == -1) | ||
3336 | return NULL((void*)0); | ||
3337 | |||
3338 | Py_INCREF(self->offset)( _Py_RefTotal++ , ((PyObject*)(self->offset))->ob_refcnt ++); | ||
3339 | return self->offset; | ||
3340 | } | ||
3341 | |||
3342 | static PyObject * | ||
3343 | timezone_dst(PyObject *self, PyObject *dt) | ||
3344 | { | ||
3345 | if (_timezone_check_argument(dt, "dst") == -1) | ||
3346 | return NULL((void*)0); | ||
3347 | |||
3348 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct); | ||
3349 | } | ||
3350 | |||
3351 | static PyObject * | ||
3352 | timezone_fromutc(PyDateTime_TimeZone *self, PyDateTime_DateTime *dt) | ||
3353 | { | ||
3354 | if (!PyDateTime_Check(dt)((((PyObject*)(dt))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(dt))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
3355 | PyErr_SetString(PyExc_TypeError, | ||
3356 | "fromutc: argument must be a datetime"); | ||
3357 | return NULL((void*)0); | ||
3358 | } | ||
3359 | if (!HASTZINFO(dt)(((_PyDateTime_BaseTZInfo *)(dt))->hastzinfo) || dt->tzinfo != (PyObject *)self) { | ||
3360 | PyErr_SetString(PyExc_ValueError, "fromutc: dt.tzinfo " | ||
3361 | "is not self"); | ||
3362 | return NULL((void*)0); | ||
3363 | } | ||
3364 | |||
3365 | return add_datetime_timedelta(dt, (PyDateTime_Delta *)self->offset, 1); | ||
3366 | } | ||
3367 | |||
3368 | static PyObject * | ||
3369 | timezone_getinitargs(PyDateTime_TimeZone *self) | ||
3370 | { | ||
3371 | if (self->name == NULL((void*)0)) | ||
3372 | return Py_BuildValue("(O)", self->offset); | ||
3373 | return Py_BuildValue("(OO)", self->offset, self->name); | ||
3374 | } | ||
3375 | |||
3376 | static PyMethodDef timezone_methods[] = { | ||
3377 | {"tzname", (PyCFunction)timezone_tzname, METH_O0x0008, | ||
3378 | PyDoc_STR("If name is specified when timezone is created, returns the name.""If name is specified when timezone is created, returns the name." " Otherwise returns offset as 'UTC(+|-)HH:MM'." | ||
3379 | " Otherwise returns offset as 'UTC(+|-)HH:MM'.")"If name is specified when timezone is created, returns the name." " Otherwise returns offset as 'UTC(+|-)HH:MM'."}, | ||
3380 | |||
3381 | {"utcoffset", (PyCFunction)timezone_utcoffset, METH_O0x0008, | ||
3382 | PyDoc_STR("Return fixed offset.")"Return fixed offset."}, | ||
3383 | |||
3384 | {"dst", (PyCFunction)timezone_dst, METH_O0x0008, | ||
3385 | PyDoc_STR("Return None.")"Return None."}, | ||
3386 | |||
3387 | {"fromutc", (PyCFunction)timezone_fromutc, METH_O0x0008, | ||
3388 | PyDoc_STR("datetime in UTC -> datetime in local time.")"datetime in UTC -> datetime in local time."}, | ||
3389 | |||
3390 | {"__getinitargs__", (PyCFunction)timezone_getinitargs, METH_NOARGS0x0004, | ||
3391 | PyDoc_STR("pickle support")"pickle support"}, | ||
3392 | |||
3393 | {NULL((void*)0), NULL((void*)0)} | ||
3394 | }; | ||
3395 | |||
3396 | static char timezone_doc[] = | ||
3397 | PyDoc_STR("Fixed offset from UTC implementation of tzinfo.")"Fixed offset from UTC implementation of tzinfo."; | ||
3398 | |||
3399 | static PyTypeObject PyDateTime_TimeZoneType = { | ||
3400 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
3401 | "datetime.timezone", /* tp_name */ | ||
3402 | sizeof(PyDateTime_TimeZone), /* tp_basicsize */ | ||
3403 | 0, /* tp_itemsize */ | ||
3404 | (destructor)timezone_dealloc, /* tp_dealloc */ | ||
3405 | 0, /* tp_print */ | ||
3406 | 0, /* tp_getattr */ | ||
3407 | 0, /* tp_setattr */ | ||
3408 | 0, /* tp_reserved */ | ||
3409 | (reprfunc)timezone_repr, /* tp_repr */ | ||
3410 | 0, /* tp_as_number */ | ||
3411 | 0, /* tp_as_sequence */ | ||
3412 | 0, /* tp_as_mapping */ | ||
3413 | (hashfunc)timezone_hash, /* tp_hash */ | ||
3414 | 0, /* tp_call */ | ||
3415 | (reprfunc)timezone_str, /* tp_str */ | ||
3416 | 0, /* tp_getattro */ | ||
3417 | 0, /* tp_setattro */ | ||
3418 | 0, /* tp_as_buffer */ | ||
3419 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0), /* tp_flags */ | ||
3420 | timezone_doc, /* tp_doc */ | ||
3421 | 0, /* tp_traverse */ | ||
3422 | 0, /* tp_clear */ | ||
3423 | (richcmpfunc)timezone_richcompare,/* tp_richcompare */ | ||
3424 | 0, /* tp_weaklistoffset */ | ||
3425 | 0, /* tp_iter */ | ||
3426 | 0, /* tp_iternext */ | ||
3427 | timezone_methods, /* tp_methods */ | ||
3428 | 0, /* tp_members */ | ||
3429 | 0, /* tp_getset */ | ||
3430 | &PyDateTime_TZInfoType, /* tp_base */ | ||
3431 | 0, /* tp_dict */ | ||
3432 | 0, /* tp_descr_get */ | ||
3433 | 0, /* tp_descr_set */ | ||
3434 | 0, /* tp_dictoffset */ | ||
3435 | 0, /* tp_init */ | ||
3436 | 0, /* tp_alloc */ | ||
3437 | timezone_new, /* tp_new */ | ||
3438 | }; | ||
3439 | |||
3440 | /* | ||
3441 | * PyDateTime_Time implementation. | ||
3442 | */ | ||
3443 | |||
3444 | /* Accessor properties. | ||
3445 | */ | ||
3446 | |||
3447 | static PyObject * | ||
3448 | time_hour(PyDateTime_Time *self, void *unused) | ||
3449 | { | ||
3450 | return PyLong_FromLong(TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0])); | ||
3451 | } | ||
3452 | |||
3453 | static PyObject * | ||
3454 | time_minute(PyDateTime_Time *self, void *unused) | ||
3455 | { | ||
3456 | return PyLong_FromLong(TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1])); | ||
3457 | } | ||
3458 | |||
3459 | /* The name time_second conflicted with some platform header file. */ | ||
3460 | static PyObject * | ||
3461 | py_time_second(PyDateTime_Time *self, void *unused) | ||
3462 | { | ||
3463 | return PyLong_FromLong(TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2])); | ||
3464 | } | ||
3465 | |||
3466 | static PyObject * | ||
3467 | time_microsecond(PyDateTime_Time *self, void *unused) | ||
3468 | { | ||
3469 | return PyLong_FromLong(TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5])); | ||
3470 | } | ||
3471 | |||
3472 | static PyObject * | ||
3473 | time_tzinfo(PyDateTime_Time *self, void *unused) | ||
3474 | { | ||
3475 | PyObject *result = HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? self->tzinfo : Py_None(&_Py_NoneStruct); | ||
3476 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
3477 | return result; | ||
3478 | } | ||
3479 | |||
3480 | static PyGetSetDef time_getset[] = { | ||
3481 | {"hour", (getter)time_hour}, | ||
3482 | {"minute", (getter)time_minute}, | ||
3483 | {"second", (getter)py_time_second}, | ||
3484 | {"microsecond", (getter)time_microsecond}, | ||
3485 | {"tzinfo", (getter)time_tzinfo}, | ||
3486 | {NULL((void*)0)} | ||
3487 | }; | ||
3488 | |||
3489 | /* | ||
3490 | * Constructors. | ||
3491 | */ | ||
3492 | |||
3493 | static char *time_kws[] = {"hour", "minute", "second", "microsecond", | ||
3494 | "tzinfo", NULL((void*)0)}; | ||
3495 | |||
3496 | static PyObject * | ||
3497 | time_new(PyTypeObject *type, PyObject *args, PyObject *kw) | ||
3498 | { | ||
3499 | PyObject *self = NULL((void*)0); | ||
3500 | PyObject *state; | ||
3501 | int hour = 0; | ||
3502 | int minute = 0; | ||
3503 | int second = 0; | ||
3504 | int usecond = 0; | ||
3505 | PyObject *tzinfo = Py_None(&_Py_NoneStruct); | ||
3506 | |||
3507 | /* Check for invocation from pickle with __getstate__ state */ | ||
3508 | if (PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) >= 1 && | ||
3509 | PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) <= 2 && | ||
3510 | PyBytes_Check(state = PyTuple_GET_ITEM(args, 0))((((((PyObject*)(state = (((PyTupleObject *)(args))->ob_item [0])))->ob_type))->tp_flags & ((1L<<27))) != 0 ) && | ||
3511 | PyBytes_GET_SIZE(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3511, "PyBytes_Check(state)") : (void)0),(((PyVarObject*)(state ))->ob_size)) == _PyDateTime_TIME_DATASIZE6 && | ||
3512 | ((unsigned char) (PyBytes_AS_STRING(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3512, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval))[0])) < 24) | ||
3513 | { | ||
3514 | PyDateTime_Time *me; | ||
3515 | char aware; | ||
3516 | |||
3517 | if (PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) == 2) { | ||
3518 | tzinfo = PyTuple_GET_ITEM(args, 1)(((PyTupleObject *)(args))->ob_item[1]); | ||
3519 | if (check_tzinfo_subclass(tzinfo) < 0) { | ||
3520 | PyErr_SetString(PyExc_TypeError, "bad " | ||
3521 | "tzinfo state arg"); | ||
3522 | return NULL((void*)0); | ||
3523 | } | ||
3524 | } | ||
3525 | aware = (char)(tzinfo != Py_None(&_Py_NoneStruct)); | ||
3526 | me = (PyDateTime_Time *) (type->tp_alloc(type, aware)); | ||
3527 | if (me != NULL((void*)0)) { | ||
3528 | char *pdata = PyBytes_AS_STRING(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3528, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval)); | ||
3529 | |||
3530 | memcpy(me->data, pdata, _PyDateTime_TIME_DATASIZE)((__builtin_object_size (me->data, 0) != (size_t) -1) ? __builtin___memcpy_chk (me->data, pdata, 6, __builtin_object_size (me->data, 0 )) : __inline_memcpy_chk (me->data, pdata, 6)); | ||
3531 | me->hashcode = -1; | ||
3532 | me->hastzinfo = aware; | ||
3533 | if (aware) { | ||
3534 | Py_INCREF(tzinfo)( _Py_RefTotal++ , ((PyObject*)(tzinfo))->ob_refcnt++); | ||
3535 | me->tzinfo = tzinfo; | ||
3536 | } | ||
3537 | } | ||
3538 | return (PyObject *)me; | ||
3539 | } | ||
3540 | |||
3541 | if (PyArg_ParseTupleAndKeywords(args, kw, "|iiiiO", time_kws, | ||
3542 | &hour, &minute, &second, &usecond, | ||
3543 | &tzinfo)) { | ||
3544 | if (check_time_args(hour, minute, second, usecond) < 0) | ||
3545 | return NULL((void*)0); | ||
3546 | if (check_tzinfo_subclass(tzinfo) < 0) | ||
3547 | return NULL((void*)0); | ||
3548 | self = new_time_ex(hour, minute, second, usecond, tzinfo, | ||
3549 | type); | ||
3550 | } | ||
3551 | return self; | ||
3552 | } | ||
3553 | |||
3554 | /* | ||
3555 | * Destructor. | ||
3556 | */ | ||
3557 | |||
3558 | static void | ||
3559 | time_dealloc(PyDateTime_Time *self) | ||
3560 | { | ||
3561 | if (HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) { | ||
3562 | Py_XDECREF(self->tzinfo)do { if ((self->tzinfo) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(self->tzinfo))->ob_refcnt != 0) { if (((PyObject*)self->tzinfo)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3562, (PyObject *)(self->tzinfo)); } else _Py_Dealloc((PyObject *)(self->tzinfo)); } while (0); } while (0); | ||
3563 | } | ||
3564 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject *)self); | ||
3565 | } | ||
3566 | |||
3567 | /* | ||
3568 | * Indirect access to tzinfo methods. | ||
3569 | */ | ||
3570 | |||
3571 | /* These are all METH_NOARGS, so don't need to check the arglist. */ | ||
3572 | static PyObject * | ||
3573 | time_utcoffset(PyObject *self, PyObject *unused) { | ||
3574 | return call_utcoffset(GET_TIME_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_Time *)(self))->tzinfo : (&_Py_NoneStruct)), Py_None(&_Py_NoneStruct)); | ||
3575 | } | ||
3576 | |||
3577 | static PyObject * | ||
3578 | time_dst(PyObject *self, PyObject *unused) { | ||
3579 | return call_dst(GET_TIME_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_Time *)(self))->tzinfo : (&_Py_NoneStruct)), Py_None(&_Py_NoneStruct)); | ||
3580 | } | ||
3581 | |||
3582 | static PyObject * | ||
3583 | time_tzname(PyDateTime_Time *self, PyObject *unused) { | ||
3584 | return call_tzname(GET_TIME_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_Time *)(self))->tzinfo : (&_Py_NoneStruct)), Py_None(&_Py_NoneStruct)); | ||
3585 | } | ||
3586 | |||
3587 | /* | ||
3588 | * Various ways to turn a time into a string. | ||
3589 | */ | ||
3590 | |||
3591 | static PyObject * | ||
3592 | time_repr(PyDateTime_Time *self) | ||
3593 | { | ||
3594 | const char *type_name = Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name; | ||
3595 | int h = TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]); | ||
3596 | int m = TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]); | ||
3597 | int s = TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]); | ||
3598 | int us = TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5]); | ||
3599 | PyObject *result = NULL((void*)0); | ||
3600 | |||
3601 | if (us) | ||
3602 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d, %d, %d)", | ||
3603 | type_name, h, m, s, us); | ||
3604 | else if (s) | ||
3605 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d, %d)", | ||
3606 | type_name, h, m, s); | ||
3607 | else | ||
3608 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%s(%d, %d)", type_name, h, m); | ||
3609 | if (result != NULL((void*)0) && HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) | ||
3610 | result = append_keyword_tzinfo(result, self->tzinfo); | ||
3611 | return result; | ||
3612 | } | ||
3613 | |||
3614 | static PyObject * | ||
3615 | time_str(PyDateTime_Time *self) | ||
3616 | { | ||
3617 | return PyObject_CallMethod((PyObject *)self, "isoformat", "()"); | ||
3618 | } | ||
3619 | |||
3620 | static PyObject * | ||
3621 | time_isoformat(PyDateTime_Time *self, PyObject *unused) | ||
3622 | { | ||
3623 | char buf[100]; | ||
3624 | PyObject *result; | ||
3625 | int us = TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5]);; | ||
3626 | |||
3627 | if (us) | ||
3628 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%02d:%02d:%02d.%06d", | ||
3629 | TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]), | ||
3630 | TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]), | ||
3631 | TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]), | ||
3632 | us); | ||
3633 | else | ||
3634 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%02d:%02d:%02d", | ||
3635 | TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]), | ||
3636 | TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]), | ||
3637 | TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2])); | ||
3638 | |||
3639 | if (result == NULL((void*)0) || !HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) || self->tzinfo == Py_None(&_Py_NoneStruct)) | ||
3640 | return result; | ||
3641 | |||
3642 | /* We need to append the UTC offset. */ | ||
3643 | if (format_utcoffset(buf, sizeof(buf), ":", self->tzinfo, | ||
3644 | Py_None(&_Py_NoneStruct)) < 0) { | ||
3645 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3645, (PyObject *)(result)); } else _Py_Dealloc((PyObject * )(result)); } while (0); | ||
3646 | return NULL((void*)0); | ||
3647 | } | ||
3648 | PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&result, PyUnicode_FromStringPyUnicodeUCS2_FromString(buf)); | ||
3649 | return result; | ||
3650 | } | ||
3651 | |||
3652 | static PyObject * | ||
3653 | time_strftime(PyDateTime_Time *self, PyObject *args, PyObject *kw) | ||
3654 | { | ||
3655 | PyObject *result; | ||
3656 | PyObject *tuple; | ||
3657 | PyObject *format; | ||
3658 | static char *keywords[] = {"format", NULL((void*)0)}; | ||
3659 | |||
3660 | if (! PyArg_ParseTupleAndKeywords(args, kw, "U:strftime", keywords, | ||
3661 | &format)) | ||
3662 | return NULL((void*)0); | ||
3663 | |||
3664 | /* Python's strftime does insane things with the year part of the | ||
3665 | * timetuple. The year is forced to (the otherwise nonsensical) | ||
3666 | * 1900 to work around that. | ||
3667 | */ | ||
3668 | tuple = Py_BuildValue("iiiiiiiii", | ||
3669 | 1900, 1, 1, /* year, month, day */ | ||
3670 | TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]), | ||
3671 | TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]), | ||
3672 | TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]), | ||
3673 | 0, 1, -1); /* weekday, daynum, dst */ | ||
3674 | if (tuple == NULL((void*)0)) | ||
3675 | return NULL((void*)0); | ||
3676 | assert(PyTuple_Size(tuple) == 9)(__builtin_expect(!(PyTuple_Size(tuple) == 9), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3676, "PyTuple_Size(tuple) == 9") : (void)0); | ||
3677 | result = wrap_strftime((PyObject *)self, format, tuple, | ||
3678 | Py_None(&_Py_NoneStruct)); | ||
3679 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3679, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
3680 | return result; | ||
3681 | } | ||
3682 | |||
3683 | /* | ||
3684 | * Miscellaneous methods. | ||
3685 | */ | ||
3686 | |||
3687 | static PyObject * | ||
3688 | time_richcompare(PyObject *self, PyObject *other, int op) | ||
3689 | { | ||
3690 | PyObject *result = NULL((void*)0); | ||
3691 | PyObject *offset1, *offset2; | ||
3692 | int diff; | ||
3693 | |||
3694 | if (! PyTime_Check(other)((((PyObject*)(other))->ob_type) == (&PyDateTime_TimeType ) || PyType_IsSubtype((((PyObject*)(other))->ob_type), (& PyDateTime_TimeType)))) { | ||
3695 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
3696 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
3697 | } | ||
3698 | |||
3699 | if (GET_TIME_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_Time *)(self))->tzinfo : (&_Py_NoneStruct)) == GET_TIME_TZINFO(other)((((_PyDateTime_BaseTZInfo *)(other))->hastzinfo) ? ((PyDateTime_Time *)(other))->tzinfo : (&_Py_NoneStruct))) { | ||
3700 | diff = memcmp(((PyDateTime_Time *)self)->data, | ||
3701 | ((PyDateTime_Time *)other)->data, | ||
3702 | _PyDateTime_TIME_DATASIZE6); | ||
3703 | return diff_to_bool(diff, op); | ||
3704 | } | ||
3705 | offset1 = time_utcoffset(self, NULL((void*)0)); | ||
3706 | if (offset1 == NULL((void*)0)) | ||
3707 | return NULL((void*)0); | ||
3708 | offset2 = time_utcoffset(other, NULL((void*)0)); | ||
3709 | if (offset2 == NULL((void*)0)) | ||
3710 | goto done; | ||
3711 | /* If they're both naive, or both aware and have the same offsets, | ||
3712 | * we get off cheap. Note that if they're both naive, offset1 == | ||
3713 | * offset2 == Py_None at this point. | ||
3714 | */ | ||
3715 | if ((offset1 == offset2) || | ||
3716 | (PyDelta_Check(offset1)((((PyObject*)(offset1))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(offset1))->ob_type), ( &PyDateTime_DeltaType))) && PyDelta_Check(offset2)((((PyObject*)(offset2))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(offset2))->ob_type), ( &PyDateTime_DeltaType))) && | ||
3717 | delta_cmp(offset1, offset2) == 0)) { | ||
3718 | diff = memcmp(((PyDateTime_Time *)self)->data, | ||
3719 | ((PyDateTime_Time *)other)->data, | ||
3720 | _PyDateTime_TIME_DATASIZE6); | ||
3721 | result = diff_to_bool(diff, op); | ||
3722 | } | ||
3723 | /* The hard case: both aware with different UTC offsets */ | ||
3724 | else if (offset1 != Py_None(&_Py_NoneStruct) && offset2 != Py_None(&_Py_NoneStruct)) { | ||
3725 | int offsecs1, offsecs2; | ||
3726 | assert(offset1 != offset2)(__builtin_expect(!(offset1 != offset2), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3726, "offset1 != offset2") : (void)0); /* else last "if" handled it */ | ||
3727 | offsecs1 = TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]) * 3600 + | ||
3728 | TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]) * 60 + | ||
3729 | TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]) - | ||
3730 | GET_TD_DAYS(offset1)(((PyDateTime_Delta *)(offset1))->days) * 86400 - | ||
3731 | GET_TD_SECONDS(offset1)(((PyDateTime_Delta *)(offset1))->seconds); | ||
3732 | offsecs2 = TIME_GET_HOUR(other)(((PyDateTime_Time*)other)->data[0]) * 3600 + | ||
3733 | TIME_GET_MINUTE(other)(((PyDateTime_Time*)other)->data[1]) * 60 + | ||
3734 | TIME_GET_SECOND(other)(((PyDateTime_Time*)other)->data[2]) - | ||
3735 | GET_TD_DAYS(offset2)(((PyDateTime_Delta *)(offset2))->days) * 86400 - | ||
3736 | GET_TD_SECONDS(offset2)(((PyDateTime_Delta *)(offset2))->seconds); | ||
3737 | diff = offsecs1 - offsecs2; | ||
3738 | if (diff == 0) | ||
3739 | diff = TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5]) - | ||
3740 | TIME_GET_MICROSECOND(other)((((PyDateTime_Time*)other)->data[3] << 16) | (((PyDateTime_Time *)other)->data[4] << 8) | ((PyDateTime_Time*)other)-> data[5]); | ||
3741 | result = diff_to_bool(diff, op); | ||
3742 | } | ||
3743 | else { | ||
3744 | PyErr_SetString(PyExc_TypeError, | ||
3745 | "can't compare offset-naive and " | ||
3746 | "offset-aware times"); | ||
3747 | } | ||
3748 | done: | ||
3749 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3749, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
3750 | Py_XDECREF(offset2)do { if ((offset2) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(offset2))->ob_refcnt != 0) { if (((PyObject *)offset2)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3750, (PyObject *)(offset2)); } else _Py_Dealloc((PyObject * )(offset2)); } while (0); } while (0); | ||
3751 | return result; | ||
3752 | } | ||
3753 | |||
3754 | static Py_hash_t | ||
3755 | time_hash(PyDateTime_Time *self) | ||
3756 | { | ||
3757 | if (self->hashcode == -1) { | ||
3758 | PyObject *offset; | ||
3759 | |||
3760 | offset = time_utcoffset((PyObject *)self, NULL((void*)0)); | ||
3761 | |||
3762 | if (offset == NULL((void*)0)) | ||
3763 | return -1; | ||
3764 | |||
3765 | /* Reduce this to a hash of another object. */ | ||
3766 | if (offset == Py_None(&_Py_NoneStruct)) | ||
3767 | self->hashcode = generic_hash( | ||
3768 | (unsigned char *)self->data, _PyDateTime_TIME_DATASIZE6); | ||
3769 | else { | ||
3770 | PyObject *temp1, *temp2; | ||
3771 | int seconds, microseconds; | ||
3772 | assert(HASTZINFO(self))(__builtin_expect(!((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo )), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3772, "HASTZINFO(self)") : (void)0); | ||
3773 | seconds = TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]) * 3600 + | ||
3774 | TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]) * 60 + | ||
3775 | TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]); | ||
3776 | microseconds = TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5]); | ||
3777 | temp1 = new_delta(0, seconds, microseconds, 1)new_delta_ex(0, seconds, microseconds, 1, &PyDateTime_DeltaType ); | ||
3778 | if (temp1 == NULL((void*)0)) { | ||
3779 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3779, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
3780 | return -1; | ||
3781 | } | ||
3782 | temp2 = delta_subtract(temp1, offset); | ||
3783 | Py_DECREF(temp1)do { if (_Py_RefTotal-- , --((PyObject*)(temp1))->ob_refcnt != 0) { if (((PyObject*)temp1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3783, (PyObject *)(temp1)); } else _Py_Dealloc((PyObject *) (temp1)); } while (0); | ||
3784 | if (temp2 == NULL((void*)0)) { | ||
3785 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3785, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
3786 | return -1; | ||
3787 | } | ||
3788 | self->hashcode = PyObject_Hash(temp2); | ||
3789 | Py_DECREF(temp2)do { if (_Py_RefTotal-- , --((PyObject*)(temp2))->ob_refcnt != 0) { if (((PyObject*)temp2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3789, (PyObject *)(temp2)); } else _Py_Dealloc((PyObject *) (temp2)); } while (0); | ||
3790 | } | ||
3791 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3791, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
3792 | } | ||
3793 | return self->hashcode; | ||
3794 | } | ||
3795 | |||
3796 | static PyObject * | ||
3797 | time_replace(PyDateTime_Time *self, PyObject *args, PyObject *kw) | ||
3798 | { | ||
3799 | PyObject *clone; | ||
3800 | PyObject *tuple; | ||
3801 | int hh = TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0]); | ||
3802 | int mm = TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1]); | ||
3803 | int ss = TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]); | ||
3804 | int us = TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5]); | ||
3805 | PyObject *tzinfo = HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? self->tzinfo : Py_None(&_Py_NoneStruct); | ||
3806 | |||
3807 | if (! PyArg_ParseTupleAndKeywords(args, kw, "|iiiiO:replace", | ||
3808 | time_kws, | ||
3809 | &hh, &mm, &ss, &us, &tzinfo)) | ||
3810 | return NULL((void*)0); | ||
3811 | tuple = Py_BuildValue("iiiiO", hh, mm, ss, us, tzinfo); | ||
3812 | if (tuple == NULL((void*)0)) | ||
3813 | return NULL((void*)0); | ||
3814 | clone = time_new(Py_TYPE(self)(((PyObject*)(self))->ob_type), tuple, NULL((void*)0)); | ||
3815 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3815, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
3816 | return clone; | ||
3817 | } | ||
3818 | |||
3819 | static int | ||
3820 | time_bool(PyObject *self) | ||
3821 | { | ||
3822 | PyObject *offset, *tzinfo; | ||
3823 | int offsecs = 0; | ||
3824 | |||
3825 | if (TIME_GET_SECOND(self)(((PyDateTime_Time*)self)->data[2]) || TIME_GET_MICROSECOND(self)((((PyDateTime_Time*)self)->data[3] << 16) | (((PyDateTime_Time *)self)->data[4] << 8) | ((PyDateTime_Time*)self)-> data[5])) { | ||
3826 | /* Since utcoffset is in whole minutes, nothing can | ||
3827 | * alter the conclusion that this is nonzero. | ||
3828 | */ | ||
3829 | return 1; | ||
3830 | } | ||
3831 | tzinfo = GET_TIME_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_Time *)(self))->tzinfo : (&_Py_NoneStruct)); | ||
3832 | if (tzinfo != Py_None(&_Py_NoneStruct)) { | ||
3833 | offset = call_utcoffset(tzinfo, Py_None(&_Py_NoneStruct)); | ||
3834 | if (offset == NULL((void*)0)) | ||
3835 | return -1; | ||
3836 | offsecs = GET_TD_DAYS(offset)(((PyDateTime_Delta *)(offset))->days)*86400 + GET_TD_SECONDS(offset)(((PyDateTime_Delta *)(offset))->seconds); | ||
3837 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3837, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
3838 | } | ||
3839 | return (TIME_GET_MINUTE(self)(((PyDateTime_Time*)self)->data[1])*60 - offsecs + TIME_GET_HOUR(self)(((PyDateTime_Time*)self)->data[0])*3600) != 0; | ||
3840 | } | ||
3841 | |||
3842 | /* Pickle support, a simple use of __reduce__. */ | ||
3843 | |||
3844 | /* Let basestate be the non-tzinfo data string. | ||
3845 | * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo). | ||
3846 | * So it's a tuple in any (non-error) case. | ||
3847 | * __getstate__ isn't exposed. | ||
3848 | */ | ||
3849 | static PyObject * | ||
3850 | time_getstate(PyDateTime_Time *self) | ||
3851 | { | ||
3852 | PyObject *basestate; | ||
3853 | PyObject *result = NULL((void*)0); | ||
3854 | |||
3855 | basestate = PyBytes_FromStringAndSize((char *)self->data, | ||
3856 | _PyDateTime_TIME_DATASIZE6); | ||
3857 | if (basestate != NULL((void*)0)) { | ||
3858 | if (! HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) || self->tzinfo == Py_None(&_Py_NoneStruct)) | ||
3859 | result = PyTuple_Pack(1, basestate); | ||
3860 | else | ||
3861 | result = PyTuple_Pack(2, basestate, self->tzinfo); | ||
3862 | Py_DECREF(basestate)do { if (_Py_RefTotal-- , --((PyObject*)(basestate))->ob_refcnt != 0) { if (((PyObject*)basestate)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 3862, (PyObject *)(basestate)); } else _Py_Dealloc((PyObject *)(basestate)); } while (0); | ||
3863 | } | ||
3864 | return result; | ||
3865 | } | ||
3866 | |||
3867 | static PyObject * | ||
3868 | time_reduce(PyDateTime_Time *self, PyObject *arg) | ||
3869 | { | ||
3870 | return Py_BuildValue("(ON)", Py_TYPE(self)(((PyObject*)(self))->ob_type), time_getstate(self)); | ||
3871 | } | ||
3872 | |||
3873 | static PyMethodDef time_methods[] = { | ||
3874 | |||
3875 | {"isoformat", (PyCFunction)time_isoformat, METH_NOARGS0x0004, | ||
3876 | PyDoc_STR("Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]""Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]" "[+HH:MM]." | ||
3877 | "[+HH:MM].")"Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]" "[+HH:MM]."}, | ||
3878 | |||
3879 | {"strftime", (PyCFunction)time_strftime, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
3880 | PyDoc_STR("format -> strftime() style string.")"format -> strftime() style string."}, | ||
3881 | |||
3882 | {"__format__", (PyCFunction)date_format, METH_VARARGS0x0001, | ||
3883 | PyDoc_STR("Formats self with strftime.")"Formats self with strftime."}, | ||
3884 | |||
3885 | {"utcoffset", (PyCFunction)time_utcoffset, METH_NOARGS0x0004, | ||
3886 | PyDoc_STR("Return self.tzinfo.utcoffset(self).")"Return self.tzinfo.utcoffset(self)."}, | ||
3887 | |||
3888 | {"tzname", (PyCFunction)time_tzname, METH_NOARGS0x0004, | ||
3889 | PyDoc_STR("Return self.tzinfo.tzname(self).")"Return self.tzinfo.tzname(self)."}, | ||
3890 | |||
3891 | {"dst", (PyCFunction)time_dst, METH_NOARGS0x0004, | ||
3892 | PyDoc_STR("Return self.tzinfo.dst(self).")"Return self.tzinfo.dst(self)."}, | ||
3893 | |||
3894 | {"replace", (PyCFunction)time_replace, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
3895 | PyDoc_STR("Return time with new specified fields.")"Return time with new specified fields."}, | ||
3896 | |||
3897 | {"__reduce__", (PyCFunction)time_reduce, METH_NOARGS0x0004, | ||
3898 | PyDoc_STR("__reduce__() -> (cls, state)")"__reduce__() -> (cls, state)"}, | ||
3899 | |||
3900 | {NULL((void*)0), NULL((void*)0)} | ||
3901 | }; | ||
3902 | |||
3903 | static char time_doc[] = | ||
3904 | PyDoc_STR("time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\"time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
3905 | \n\"time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
3906 | All arguments are optional. tzinfo may be None, or an instance of\n\"time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
3907 | a tzinfo subclass. The remaining arguments may be ints or longs.\n")"time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints or longs.\n"; | ||
3908 | |||
3909 | static PyNumberMethods time_as_number = { | ||
3910 | 0, /* nb_add */ | ||
3911 | 0, /* nb_subtract */ | ||
3912 | 0, /* nb_multiply */ | ||
3913 | 0, /* nb_remainder */ | ||
3914 | 0, /* nb_divmod */ | ||
3915 | 0, /* nb_power */ | ||
3916 | 0, /* nb_negative */ | ||
3917 | 0, /* nb_positive */ | ||
3918 | 0, /* nb_absolute */ | ||
3919 | (inquiry)time_bool, /* nb_bool */ | ||
3920 | }; | ||
3921 | |||
3922 | static PyTypeObject PyDateTime_TimeType = { | ||
3923 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
3924 | "datetime.time", /* tp_name */ | ||
3925 | sizeof(PyDateTime_Time), /* tp_basicsize */ | ||
3926 | 0, /* tp_itemsize */ | ||
3927 | (destructor)time_dealloc, /* tp_dealloc */ | ||
3928 | 0, /* tp_print */ | ||
3929 | 0, /* tp_getattr */ | ||
3930 | 0, /* tp_setattr */ | ||
3931 | 0, /* tp_reserved */ | ||
3932 | (reprfunc)time_repr, /* tp_repr */ | ||
3933 | &time_as_number, /* tp_as_number */ | ||
3934 | 0, /* tp_as_sequence */ | ||
3935 | 0, /* tp_as_mapping */ | ||
3936 | (hashfunc)time_hash, /* tp_hash */ | ||
3937 | 0, /* tp_call */ | ||
3938 | (reprfunc)time_str, /* tp_str */ | ||
3939 | PyObject_GenericGetAttr, /* tp_getattro */ | ||
3940 | 0, /* tp_setattro */ | ||
3941 | 0, /* tp_as_buffer */ | ||
3942 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_BASETYPE(1L<<10), /* tp_flags */ | ||
3943 | time_doc, /* tp_doc */ | ||
3944 | 0, /* tp_traverse */ | ||
3945 | 0, /* tp_clear */ | ||
3946 | time_richcompare, /* tp_richcompare */ | ||
3947 | 0, /* tp_weaklistoffset */ | ||
3948 | 0, /* tp_iter */ | ||
3949 | 0, /* tp_iternext */ | ||
3950 | time_methods, /* tp_methods */ | ||
3951 | 0, /* tp_members */ | ||
3952 | time_getset, /* tp_getset */ | ||
3953 | 0, /* tp_base */ | ||
3954 | 0, /* tp_dict */ | ||
3955 | 0, /* tp_descr_get */ | ||
3956 | 0, /* tp_descr_set */ | ||
3957 | 0, /* tp_dictoffset */ | ||
3958 | 0, /* tp_init */ | ||
3959 | time_alloc, /* tp_alloc */ | ||
3960 | time_new, /* tp_new */ | ||
3961 | 0, /* tp_free */ | ||
3962 | }; | ||
3963 | |||
3964 | /* | ||
3965 | * PyDateTime_DateTime implementation. | ||
3966 | */ | ||
3967 | |||
3968 | /* Accessor properties. Properties for day, month, and year are inherited | ||
3969 | * from date. | ||
3970 | */ | ||
3971 | |||
3972 | static PyObject * | ||
3973 | datetime_hour(PyDateTime_DateTime *self, void *unused) | ||
3974 | { | ||
3975 | return PyLong_FromLong(DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4])); | ||
3976 | } | ||
3977 | |||
3978 | static PyObject * | ||
3979 | datetime_minute(PyDateTime_DateTime *self, void *unused) | ||
3980 | { | ||
3981 | return PyLong_FromLong(DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5])); | ||
3982 | } | ||
3983 | |||
3984 | static PyObject * | ||
3985 | datetime_second(PyDateTime_DateTime *self, void *unused) | ||
3986 | { | ||
3987 | return PyLong_FromLong(DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6])); | ||
3988 | } | ||
3989 | |||
3990 | static PyObject * | ||
3991 | datetime_microsecond(PyDateTime_DateTime *self, void *unused) | ||
3992 | { | ||
3993 | return PyLong_FromLong(DATE_GET_MICROSECOND(self)((((PyDateTime_DateTime*)self)->data[7] << 16) | ((( PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9])); | ||
3994 | } | ||
3995 | |||
3996 | static PyObject * | ||
3997 | datetime_tzinfo(PyDateTime_DateTime *self, void *unused) | ||
3998 | { | ||
3999 | PyObject *result = HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? self->tzinfo : Py_None(&_Py_NoneStruct); | ||
4000 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
4001 | return result; | ||
4002 | } | ||
4003 | |||
4004 | static PyGetSetDef datetime_getset[] = { | ||
4005 | {"hour", (getter)datetime_hour}, | ||
4006 | {"minute", (getter)datetime_minute}, | ||
4007 | {"second", (getter)datetime_second}, | ||
4008 | {"microsecond", (getter)datetime_microsecond}, | ||
4009 | {"tzinfo", (getter)datetime_tzinfo}, | ||
4010 | {NULL((void*)0)} | ||
4011 | }; | ||
4012 | |||
4013 | /* | ||
4014 | * Constructors. | ||
4015 | */ | ||
4016 | |||
4017 | static char *datetime_kws[] = { | ||
4018 | "year", "month", "day", "hour", "minute", "second", | ||
4019 | "microsecond", "tzinfo", NULL((void*)0) | ||
4020 | }; | ||
4021 | |||
4022 | static PyObject * | ||
4023 | datetime_new(PyTypeObject *type, PyObject *args, PyObject *kw) | ||
4024 | { | ||
4025 | PyObject *self = NULL((void*)0); | ||
4026 | PyObject *state; | ||
4027 | int year; | ||
4028 | int month; | ||
4029 | int day; | ||
4030 | int hour = 0; | ||
4031 | int minute = 0; | ||
4032 | int second = 0; | ||
4033 | int usecond = 0; | ||
4034 | PyObject *tzinfo = Py_None(&_Py_NoneStruct); | ||
4035 | |||
4036 | /* Check for invocation from pickle with __getstate__ state */ | ||
4037 | if (PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) >= 1 && | ||
4038 | PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) <= 2 && | ||
4039 | PyBytes_Check(state = PyTuple_GET_ITEM(args, 0))((((((PyObject*)(state = (((PyTupleObject *)(args))->ob_item [0])))->ob_type))->tp_flags & ((1L<<27))) != 0 ) && | ||
4040 | PyBytes_GET_SIZE(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4040, "PyBytes_Check(state)") : (void)0),(((PyVarObject*)(state ))->ob_size)) == _PyDateTime_DATETIME_DATASIZE10 && | ||
4041 | MONTH_IS_SANE(PyBytes_AS_STRING(state)[2])((unsigned int)(((__builtin_expect(!(((((((PyObject*)(state)) ->ob_type))->tp_flags & ((1L<<27))) != 0)), 0 ) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4041, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval))[2]) - 1 < 12)) | ||
4042 | { | ||
4043 | PyDateTime_DateTime *me; | ||
4044 | char aware; | ||
4045 | |||
4046 | if (PyTuple_GET_SIZE(args)(((PyVarObject*)(args))->ob_size) == 2) { | ||
4047 | tzinfo = PyTuple_GET_ITEM(args, 1)(((PyTupleObject *)(args))->ob_item[1]); | ||
4048 | if (check_tzinfo_subclass(tzinfo) < 0) { | ||
4049 | PyErr_SetString(PyExc_TypeError, "bad " | ||
4050 | "tzinfo state arg"); | ||
4051 | return NULL((void*)0); | ||
4052 | } | ||
4053 | } | ||
4054 | aware = (char)(tzinfo != Py_None(&_Py_NoneStruct)); | ||
4055 | me = (PyDateTime_DateTime *) (type->tp_alloc(type , aware)); | ||
4056 | if (me != NULL((void*)0)) { | ||
4057 | char *pdata = PyBytes_AS_STRING(state)((__builtin_expect(!(((((((PyObject*)(state))->ob_type))-> tp_flags & ((1L<<27))) != 0)), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4057, "PyBytes_Check(state)") : (void)0), (((PyBytesObject * )(state))->ob_sval)); | ||
4058 | |||
4059 | memcpy(me->data, pdata, _PyDateTime_DATETIME_DATASIZE)((__builtin_object_size (me->data, 0) != (size_t) -1) ? __builtin___memcpy_chk (me->data, pdata, 10, __builtin_object_size (me->data, 0)) : __inline_memcpy_chk (me->data, pdata, 10)); | ||
4060 | me->hashcode = -1; | ||
4061 | me->hastzinfo = aware; | ||
4062 | if (aware) { | ||
4063 | Py_INCREF(tzinfo)( _Py_RefTotal++ , ((PyObject*)(tzinfo))->ob_refcnt++); | ||
4064 | me->tzinfo = tzinfo; | ||
4065 | } | ||
4066 | } | ||
4067 | return (PyObject *)me; | ||
4068 | } | ||
4069 | |||
4070 | if (PyArg_ParseTupleAndKeywords(args, kw, "iii|iiiiO", datetime_kws, | ||
4071 | &year, &month, &day, &hour, &minute, | ||
4072 | &second, &usecond, &tzinfo)) { | ||
4073 | if (check_date_args(year, month, day) < 0) | ||
4074 | return NULL((void*)0); | ||
4075 | if (check_time_args(hour, minute, second, usecond) < 0) | ||
4076 | return NULL((void*)0); | ||
4077 | if (check_tzinfo_subclass(tzinfo) < 0) | ||
4078 | return NULL((void*)0); | ||
4079 | self = new_datetime_ex(year, month, day, | ||
4080 | hour, minute, second, usecond, | ||
4081 | tzinfo, type); | ||
4082 | } | ||
4083 | return self; | ||
4084 | } | ||
4085 | |||
4086 | /* TM_FUNC is the shared type of localtime() and gmtime(). */ | ||
4087 | typedef struct tm *(*TM_FUNC)(const time_t *timer); | ||
4088 | |||
4089 | /* Internal helper. | ||
4090 | * Build datetime from a time_t and a distinct count of microseconds. | ||
4091 | * Pass localtime or gmtime for f, to control the interpretation of timet. | ||
4092 | */ | ||
4093 | static PyObject * | ||
4094 | datetime_from_timet_and_us(PyObject *cls, TM_FUNC f, time_t timet, int us, | ||
4095 | PyObject *tzinfo) | ||
4096 | { | ||
4097 | struct tm *tm; | ||
4098 | PyObject *result = NULL((void*)0); | ||
4099 | |||
4100 | tm = f(&timet); | ||
4101 | if (tm) { | ||
4102 | /* The platform localtime/gmtime may insert leap seconds, | ||
4103 | * indicated by tm->tm_sec > 59. We don't care about them, | ||
4104 | * except to the extent that passing them on to the datetime | ||
4105 | * constructor would raise ValueError for a reason that | ||
4106 | * made no sense to the user. | ||
4107 | */ | ||
4108 | if (tm->tm_sec > 59) | ||
4109 | tm->tm_sec = 59; | ||
4110 | result = PyObject_CallFunction(cls, "iiiiiiiO", | ||
4111 | tm->tm_year + 1900, | ||
4112 | tm->tm_mon + 1, | ||
4113 | tm->tm_mday, | ||
4114 | tm->tm_hour, | ||
4115 | tm->tm_min, | ||
4116 | tm->tm_sec, | ||
4117 | us, | ||
4118 | tzinfo); | ||
4119 | } | ||
4120 | else | ||
4121 | PyErr_SetString(PyExc_ValueError, | ||
4122 | "timestamp out of range for " | ||
4123 | "platform localtime()/gmtime() function"); | ||
4124 | return result; | ||
4125 | } | ||
4126 | |||
4127 | /* Internal helper. | ||
4128 | * Build datetime from a Python timestamp. Pass localtime or gmtime for f, | ||
4129 | * to control the interpretation of the timestamp. Since a double doesn't | ||
4130 | * have enough bits to cover a datetime's full range of precision, it's | ||
4131 | * better to call datetime_from_timet_and_us provided you have a way | ||
4132 | * to get that much precision (e.g., C time() isn't good enough). | ||
4133 | */ | ||
4134 | static PyObject * | ||
4135 | datetime_from_timestamp(PyObject *cls, TM_FUNC f, double timestamp, | ||
4136 | PyObject *tzinfo) | ||
4137 | { | ||
4138 | time_t timet; | ||
4139 | double fraction; | ||
4140 | int us; | ||
4141 | |||
4142 | timet = _PyTime_DoubleToTimet(timestamp); | ||
4143 | if (timet == (time_t)-1 && PyErr_Occurred()) | ||
4144 | return NULL((void*)0); | ||
4145 | fraction = timestamp - (double)timet; | ||
4146 | us = (int)round_to_long(fraction * 1e6); | ||
4147 | if (us < 0) { | ||
4148 | /* Truncation towards zero is not what we wanted | ||
4149 | for negative numbers (Python's mod semantics) */ | ||
4150 | timet -= 1; | ||
4151 | us += 1000000; | ||
4152 | } | ||
4153 | /* If timestamp is less than one microsecond smaller than a | ||
4154 | * full second, round up. Otherwise, ValueErrors are raised | ||
4155 | * for some floats. */ | ||
4156 | if (us == 1000000) { | ||
4157 | timet += 1; | ||
4158 | us = 0; | ||
4159 | } | ||
4160 | return datetime_from_timet_and_us(cls, f, timet, us, tzinfo); | ||
4161 | } | ||
4162 | |||
4163 | /* Internal helper. | ||
4164 | * Build most accurate possible datetime for current time. Pass localtime or | ||
4165 | * gmtime for f as appropriate. | ||
4166 | */ | ||
4167 | static PyObject * | ||
4168 | datetime_best_possible(PyObject *cls, TM_FUNC f, PyObject *tzinfo) | ||
4169 | { | ||
4170 | _PyTime_timeval t; | ||
4171 | _PyTime_gettimeofday(&t); | ||
4172 | return datetime_from_timet_and_us(cls, f, t.tv_sec, (int)t.tv_usec, | ||
4173 | tzinfo); | ||
4174 | } | ||
4175 | |||
4176 | /* Return best possible local time -- this isn't constrained by the | ||
4177 | * precision of a timestamp. | ||
4178 | */ | ||
4179 | static PyObject * | ||
4180 | datetime_now(PyObject *cls, PyObject *args, PyObject *kw) | ||
4181 | { | ||
4182 | PyObject *self; | ||
4183 | PyObject *tzinfo = Py_None(&_Py_NoneStruct); | ||
4184 | static char *keywords[] = {"tz", NULL((void*)0)}; | ||
4185 | |||
4186 | if (! PyArg_ParseTupleAndKeywords(args, kw, "|O:now", keywords, | ||
4187 | &tzinfo)) | ||
4188 | return NULL((void*)0); | ||
4189 | if (check_tzinfo_subclass(tzinfo) < 0) | ||
4190 | return NULL((void*)0); | ||
4191 | |||
4192 | self = datetime_best_possible(cls, | ||
4193 | tzinfo == Py_None(&_Py_NoneStruct) ? localtime : gmtime, | ||
4194 | tzinfo); | ||
4195 | if (self != NULL((void*)0) && tzinfo != Py_None(&_Py_NoneStruct)) { | ||
4196 | /* Convert UTC to tzinfo's zone. */ | ||
4197 | PyObject *temp = self; | ||
4198 | self = PyObject_CallMethod(tzinfo, "fromutc", "O", self); | ||
4199 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4199, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
4200 | } | ||
4201 | return self; | ||
4202 | } | ||
4203 | |||
4204 | /* Return best possible UTC time -- this isn't constrained by the | ||
4205 | * precision of a timestamp. | ||
4206 | */ | ||
4207 | static PyObject * | ||
4208 | datetime_utcnow(PyObject *cls, PyObject *dummy) | ||
4209 | { | ||
4210 | return datetime_best_possible(cls, gmtime, Py_None(&_Py_NoneStruct)); | ||
4211 | } | ||
4212 | |||
4213 | /* Return new local datetime from timestamp (Python timestamp -- a double). */ | ||
4214 | static PyObject * | ||
4215 | datetime_fromtimestamp(PyObject *cls, PyObject *args, PyObject *kw) | ||
4216 | { | ||
4217 | PyObject *self; | ||
4218 | double timestamp; | ||
4219 | PyObject *tzinfo = Py_None(&_Py_NoneStruct); | ||
4220 | static char *keywords[] = {"timestamp", "tz", NULL((void*)0)}; | ||
4221 | |||
4222 | if (! PyArg_ParseTupleAndKeywords(args, kw, "d|O:fromtimestamp", | ||
4223 | keywords, ×tamp, &tzinfo)) | ||
4224 | return NULL((void*)0); | ||
4225 | if (check_tzinfo_subclass(tzinfo) < 0) | ||
4226 | return NULL((void*)0); | ||
4227 | |||
4228 | self = datetime_from_timestamp(cls, | ||
4229 | tzinfo == Py_None(&_Py_NoneStruct) ? localtime : gmtime, | ||
4230 | timestamp, | ||
4231 | tzinfo); | ||
4232 | if (self != NULL((void*)0) && tzinfo != Py_None(&_Py_NoneStruct)) { | ||
4233 | /* Convert UTC to tzinfo's zone. */ | ||
4234 | PyObject *temp = self; | ||
4235 | self = PyObject_CallMethod(tzinfo, "fromutc", "O", self); | ||
4236 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4236, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
4237 | } | ||
4238 | return self; | ||
4239 | } | ||
4240 | |||
4241 | /* Return new UTC datetime from timestamp (Python timestamp -- a double). */ | ||
4242 | static PyObject * | ||
4243 | datetime_utcfromtimestamp(PyObject *cls, PyObject *args) | ||
4244 | { | ||
4245 | double timestamp; | ||
4246 | PyObject *result = NULL((void*)0); | ||
4247 | |||
4248 | if (PyArg_ParseTuple(args, "d:utcfromtimestamp", ×tamp)) | ||
4249 | result = datetime_from_timestamp(cls, gmtime, timestamp, | ||
4250 | Py_None(&_Py_NoneStruct)); | ||
4251 | return result; | ||
4252 | } | ||
4253 | |||
4254 | /* Return new datetime from _strptime.strptime_datetime(). */ | ||
4255 | static PyObject * | ||
4256 | datetime_strptime(PyObject *cls, PyObject *args) | ||
4257 | { | ||
4258 | static PyObject *module = NULL((void*)0); | ||
4259 | const Py_UNICODE *string, *format; | ||
4260 | |||
4261 | if (!PyArg_ParseTuple(args, "uu:strptime", &string, &format)) | ||
4262 | return NULL((void*)0); | ||
4263 | |||
4264 | if (module == NULL((void*)0)) { | ||
4265 | module = PyImport_ImportModuleNoBlock("_strptime"); | ||
4266 | if (module == NULL((void*)0)) | ||
4267 | return NULL((void*)0); | ||
4268 | } | ||
4269 | return PyObject_CallMethod(module, "_strptime_datetime", "Ouu", | ||
4270 | cls, string, format); | ||
4271 | } | ||
4272 | |||
4273 | /* Return new datetime from date/datetime and time arguments. */ | ||
4274 | static PyObject * | ||
4275 | datetime_combine(PyObject *cls, PyObject *args, PyObject *kw) | ||
4276 | { | ||
4277 | static char *keywords[] = {"date", "time", NULL((void*)0)}; | ||
4278 | PyObject *date; | ||
4279 | PyObject *time; | ||
4280 | PyObject *result = NULL((void*)0); | ||
4281 | |||
4282 | if (PyArg_ParseTupleAndKeywords(args, kw, "O!O!:combine", keywords, | ||
4283 | &PyDateTime_DateType, &date, | ||
4284 | &PyDateTime_TimeType, &time)) { | ||
4285 | PyObject *tzinfo = Py_None(&_Py_NoneStruct); | ||
4286 | |||
4287 | if (HASTZINFO(time)(((_PyDateTime_BaseTZInfo *)(time))->hastzinfo)) | ||
4288 | tzinfo = ((PyDateTime_Time *)time)->tzinfo; | ||
4289 | result = PyObject_CallFunction(cls, "iiiiiiiO", | ||
4290 | GET_YEAR(date)((((PyDateTime_Date*)date)->data[0] << 8) | ((PyDateTime_Date *)date)->data[1]), | ||
4291 | GET_MONTH(date)(((PyDateTime_Date*)date)->data[2]), | ||
4292 | GET_DAY(date)(((PyDateTime_Date*)date)->data[3]), | ||
4293 | TIME_GET_HOUR(time)(((PyDateTime_Time*)time)->data[0]), | ||
4294 | TIME_GET_MINUTE(time)(((PyDateTime_Time*)time)->data[1]), | ||
4295 | TIME_GET_SECOND(time)(((PyDateTime_Time*)time)->data[2]), | ||
4296 | TIME_GET_MICROSECOND(time)((((PyDateTime_Time*)time)->data[3] << 16) | (((PyDateTime_Time *)time)->data[4] << 8) | ((PyDateTime_Time*)time)-> data[5]), | ||
4297 | tzinfo); | ||
4298 | } | ||
4299 | return result; | ||
4300 | } | ||
4301 | |||
4302 | /* | ||
4303 | * Destructor. | ||
4304 | */ | ||
4305 | |||
4306 | static void | ||
4307 | datetime_dealloc(PyDateTime_DateTime *self) | ||
4308 | { | ||
4309 | if (HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) { | ||
4310 | Py_XDECREF(self->tzinfo)do { if ((self->tzinfo) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(self->tzinfo))->ob_refcnt != 0) { if (((PyObject*)self->tzinfo)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4310, (PyObject *)(self->tzinfo)); } else _Py_Dealloc((PyObject *)(self->tzinfo)); } while (0); } while (0); | ||
4311 | } | ||
4312 | Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_free((PyObject *)self); | ||
4313 | } | ||
4314 | |||
4315 | /* | ||
4316 | * Indirect access to tzinfo methods. | ||
4317 | */ | ||
4318 | |||
4319 | /* These are all METH_NOARGS, so don't need to check the arglist. */ | ||
4320 | static PyObject * | ||
4321 | datetime_utcoffset(PyObject *self, PyObject *unused) { | ||
4322 | return call_utcoffset(GET_DT_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (&_Py_NoneStruct)), self); | ||
4323 | } | ||
4324 | |||
4325 | static PyObject * | ||
4326 | datetime_dst(PyObject *self, PyObject *unused) { | ||
4327 | return call_dst(GET_DT_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (&_Py_NoneStruct)), self); | ||
4328 | } | ||
4329 | |||
4330 | static PyObject * | ||
4331 | datetime_tzname(PyObject *self, PyObject *unused) { | ||
4332 | return call_tzname(GET_DT_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (&_Py_NoneStruct)), self); | ||
4333 | } | ||
4334 | |||
4335 | /* | ||
4336 | * datetime arithmetic. | ||
4337 | */ | ||
4338 | |||
4339 | /* factor must be 1 (to add) or -1 (to subtract). The result inherits | ||
4340 | * the tzinfo state of date. | ||
4341 | */ | ||
4342 | static PyObject * | ||
4343 | add_datetime_timedelta(PyDateTime_DateTime *date, PyDateTime_Delta *delta, | ||
4344 | int factor) | ||
4345 | { | ||
4346 | /* Note that the C-level additions can't overflow, because of | ||
4347 | * invariant bounds on the member values. | ||
4348 | */ | ||
4349 | int year = GET_YEAR(date)((((PyDateTime_Date*)date)->data[0] << 8) | ((PyDateTime_Date *)date)->data[1]); | ||
4350 | int month = GET_MONTH(date)(((PyDateTime_Date*)date)->data[2]); | ||
4351 | int day = GET_DAY(date)(((PyDateTime_Date*)date)->data[3]) + GET_TD_DAYS(delta)(((PyDateTime_Delta *)(delta))->days) * factor; | ||
4352 | int hour = DATE_GET_HOUR(date)(((PyDateTime_DateTime*)date)->data[4]); | ||
4353 | int minute = DATE_GET_MINUTE(date)(((PyDateTime_DateTime*)date)->data[5]); | ||
4354 | int second = DATE_GET_SECOND(date)(((PyDateTime_DateTime*)date)->data[6]) + GET_TD_SECONDS(delta)(((PyDateTime_Delta *)(delta))->seconds) * factor; | ||
4355 | int microsecond = DATE_GET_MICROSECOND(date)((((PyDateTime_DateTime*)date)->data[7] << 16) | ((( PyDateTime_DateTime*)date)->data[8] << 8) | ((PyDateTime_DateTime *)date)->data[9]) + | ||
4356 | GET_TD_MICROSECONDS(delta)(((PyDateTime_Delta *)(delta))->microseconds) * factor; | ||
4357 | |||
4358 | assert(factor == 1 || factor == -1)(__builtin_expect(!(factor == 1 || factor == -1), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4358, "factor == 1 || factor == -1") : (void)0); | ||
4359 | if (normalize_datetime(&year, &month, &day, | ||
4360 | &hour, &minute, &second, µsecond) < 0) | ||
4361 | return NULL((void*)0); | ||
4362 | else | ||
4363 | return new_datetime(year, month, day,new_datetime_ex(year, month, day, hour, minute, second, microsecond , (((_PyDateTime_BaseTZInfo *)(date))->hastzinfo) ? date-> tzinfo : (&_Py_NoneStruct), &PyDateTime_DateTimeType) | ||
4364 | hour, minute, second, microsecond,new_datetime_ex(year, month, day, hour, minute, second, microsecond , (((_PyDateTime_BaseTZInfo *)(date))->hastzinfo) ? date-> tzinfo : (&_Py_NoneStruct), &PyDateTime_DateTimeType) | ||
4365 | HASTZINFO(date) ? date->tzinfo : Py_None)new_datetime_ex(year, month, day, hour, minute, second, microsecond , (((_PyDateTime_BaseTZInfo *)(date))->hastzinfo) ? date-> tzinfo : (&_Py_NoneStruct), &PyDateTime_DateTimeType); | ||
4366 | } | ||
4367 | |||
4368 | static PyObject * | ||
4369 | datetime_add(PyObject *left, PyObject *right) | ||
4370 | { | ||
4371 | if (PyDateTime_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
4372 | /* datetime + ??? */ | ||
4373 | if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) | ||
4374 | /* datetime + delta */ | ||
4375 | return add_datetime_timedelta( | ||
4376 | (PyDateTime_DateTime *)left, | ||
4377 | (PyDateTime_Delta *)right, | ||
4378 | 1); | ||
4379 | } | ||
4380 | else if (PyDelta_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DeltaType)))) { | ||
4381 | /* delta + datetime */ | ||
4382 | return add_datetime_timedelta((PyDateTime_DateTime *) right, | ||
4383 | (PyDateTime_Delta *) left, | ||
4384 | 1); | ||
4385 | } | ||
4386 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
4387 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
4388 | } | ||
4389 | |||
4390 | static PyObject * | ||
4391 | datetime_subtract(PyObject *left, PyObject *right) | ||
4392 | { | ||
4393 | PyObject *result = Py_NotImplemented(&_Py_NotImplementedStruct); | ||
4394 | |||
4395 | if (PyDateTime_Check(left)((((PyObject*)(left))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(left))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
4396 | /* datetime - ??? */ | ||
4397 | if (PyDateTime_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
4398 | /* datetime - datetime */ | ||
4399 | PyObject *offset1, *offset2, *offdiff = NULL((void*)0); | ||
4400 | int delta_d, delta_s, delta_us; | ||
4401 | |||
4402 | if (GET_DT_TZINFO(left)((((_PyDateTime_BaseTZInfo *)(left))->hastzinfo) ? ((PyDateTime_DateTime *)(left))->tzinfo : (&_Py_NoneStruct)) == GET_DT_TZINFO(right)((((_PyDateTime_BaseTZInfo *)(right))->hastzinfo) ? ((PyDateTime_DateTime *)(right))->tzinfo : (&_Py_NoneStruct))) { | ||
4403 | offset2 = offset1 = Py_None(&_Py_NoneStruct); | ||
4404 | Py_INCREF(offset1)( _Py_RefTotal++ , ((PyObject*)(offset1))->ob_refcnt++); | ||
4405 | Py_INCREF(offset2)( _Py_RefTotal++ , ((PyObject*)(offset2))->ob_refcnt++); | ||
4406 | } | ||
4407 | else { | ||
4408 | offset1 = datetime_utcoffset(left, NULL((void*)0)); | ||
4409 | if (offset1 == NULL((void*)0)) | ||
4410 | return NULL((void*)0); | ||
4411 | offset2 = datetime_utcoffset(right, NULL((void*)0)); | ||
4412 | if (offset2 == NULL((void*)0)) { | ||
4413 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4413, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
4414 | return NULL((void*)0); | ||
4415 | } | ||
4416 | if ((offset1 != Py_None(&_Py_NoneStruct)) != (offset2 != Py_None(&_Py_NoneStruct))) { | ||
4417 | PyErr_SetString(PyExc_TypeError, | ||
4418 | "can't subtract offset-naive and " | ||
4419 | "offset-aware datetimes"); | ||
4420 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4420, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
4421 | Py_DECREF(offset2)do { if (_Py_RefTotal-- , --((PyObject*)(offset2))->ob_refcnt != 0) { if (((PyObject*)offset2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4421, (PyObject *)(offset2)); } else _Py_Dealloc((PyObject * )(offset2)); } while (0); | ||
4422 | return NULL((void*)0); | ||
4423 | } | ||
4424 | } | ||
4425 | if ((offset1 != offset2) && | ||
4426 | delta_cmp(offset1, offset2) != 0) { | ||
4427 | offdiff = delta_subtract(offset1, offset2); | ||
4428 | if (offdiff == NULL((void*)0)) { | ||
4429 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4429, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
4430 | Py_DECREF(offset2)do { if (_Py_RefTotal-- , --((PyObject*)(offset2))->ob_refcnt != 0) { if (((PyObject*)offset2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4430, (PyObject *)(offset2)); } else _Py_Dealloc((PyObject * )(offset2)); } while (0); | ||
4431 | return NULL((void*)0); | ||
4432 | } | ||
4433 | } | ||
4434 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4434, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
4435 | Py_DECREF(offset2)do { if (_Py_RefTotal-- , --((PyObject*)(offset2))->ob_refcnt != 0) { if (((PyObject*)offset2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4435, (PyObject *)(offset2)); } else _Py_Dealloc((PyObject * )(offset2)); } while (0); | ||
4436 | delta_d = ymd_to_ord(GET_YEAR(left)((((PyDateTime_Date*)left)->data[0] << 8) | ((PyDateTime_Date *)left)->data[1]), | ||
4437 | GET_MONTH(left)(((PyDateTime_Date*)left)->data[2]), | ||
4438 | GET_DAY(left)(((PyDateTime_Date*)left)->data[3])) - | ||
4439 | ymd_to_ord(GET_YEAR(right)((((PyDateTime_Date*)right)->data[0] << 8) | ((PyDateTime_Date *)right)->data[1]), | ||
4440 | GET_MONTH(right)(((PyDateTime_Date*)right)->data[2]), | ||
4441 | GET_DAY(right)(((PyDateTime_Date*)right)->data[3])); | ||
4442 | /* These can't overflow, since the values are | ||
4443 | * normalized. At most this gives the number of | ||
4444 | * seconds in one day. | ||
4445 | */ | ||
4446 | delta_s = (DATE_GET_HOUR(left)(((PyDateTime_DateTime*)left)->data[4]) - | ||
4447 | DATE_GET_HOUR(right)(((PyDateTime_DateTime*)right)->data[4])) * 3600 + | ||
4448 | (DATE_GET_MINUTE(left)(((PyDateTime_DateTime*)left)->data[5]) - | ||
4449 | DATE_GET_MINUTE(right)(((PyDateTime_DateTime*)right)->data[5])) * 60 + | ||
4450 | (DATE_GET_SECOND(left)(((PyDateTime_DateTime*)left)->data[6]) - | ||
4451 | DATE_GET_SECOND(right)(((PyDateTime_DateTime*)right)->data[6])); | ||
4452 | delta_us = DATE_GET_MICROSECOND(left)((((PyDateTime_DateTime*)left)->data[7] << 16) | ((( PyDateTime_DateTime*)left)->data[8] << 8) | ((PyDateTime_DateTime *)left)->data[9]) - | ||
4453 | DATE_GET_MICROSECOND(right)((((PyDateTime_DateTime*)right)->data[7] << 16) | (( (PyDateTime_DateTime*)right)->data[8] << 8) | ((PyDateTime_DateTime *)right)->data[9]); | ||
4454 | result = new_delta(delta_d, delta_s, delta_us, 1)new_delta_ex(delta_d, delta_s, delta_us, 1, &PyDateTime_DeltaType ); | ||
4455 | if (offdiff != NULL((void*)0)) { | ||
4456 | PyObject *temp = result; | ||
4457 | result = delta_subtract(result, offdiff); | ||
4458 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4458, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
4459 | Py_DECREF(offdiff)do { if (_Py_RefTotal-- , --((PyObject*)(offdiff))->ob_refcnt != 0) { if (((PyObject*)offdiff)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4459, (PyObject *)(offdiff)); } else _Py_Dealloc((PyObject * )(offdiff)); } while (0); | ||
4460 | } | ||
4461 | } | ||
4462 | else if (PyDelta_Check(right)((((PyObject*)(right))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(right))->ob_type), (& PyDateTime_DeltaType)))) { | ||
4463 | /* datetime - delta */ | ||
4464 | result = add_datetime_timedelta( | ||
4465 | (PyDateTime_DateTime *)left, | ||
4466 | (PyDateTime_Delta *)right, | ||
4467 | -1); | ||
4468 | } | ||
4469 | } | ||
4470 | |||
4471 | if (result == Py_NotImplemented(&_Py_NotImplementedStruct)) | ||
4472 | Py_INCREF(result)( _Py_RefTotal++ , ((PyObject*)(result))->ob_refcnt++); | ||
4473 | return result; | ||
4474 | } | ||
4475 | |||
4476 | /* Various ways to turn a datetime into a string. */ | ||
4477 | |||
4478 | static PyObject * | ||
4479 | datetime_repr(PyDateTime_DateTime *self) | ||
4480 | { | ||
4481 | const char *type_name = Py_TYPE(self)(((PyObject*)(self))->ob_type)->tp_name; | ||
4482 | PyObject *baserepr; | ||
4483 | |||
4484 | if (DATE_GET_MICROSECOND(self)((((PyDateTime_DateTime*)self)->data[7] << 16) | ((( PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9])) { | ||
4485 | baserepr = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat( | ||
4486 | "%s(%d, %d, %d, %d, %d, %d, %d)", | ||
4487 | type_name, | ||
4488 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), | ||
4489 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4490 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6]), | ||
4491 | DATE_GET_MICROSECOND(self)((((PyDateTime_DateTime*)self)->data[7] << 16) | ((( PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9])); | ||
4492 | } | ||
4493 | else if (DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6])) { | ||
4494 | baserepr = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat( | ||
4495 | "%s(%d, %d, %d, %d, %d, %d)", | ||
4496 | type_name, | ||
4497 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), | ||
4498 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4499 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6])); | ||
4500 | } | ||
4501 | else { | ||
4502 | baserepr = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat( | ||
4503 | "%s(%d, %d, %d, %d, %d)", | ||
4504 | type_name, | ||
4505 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), | ||
4506 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5])); | ||
4507 | } | ||
4508 | if (baserepr == NULL((void*)0) || ! HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) | ||
4509 | return baserepr; | ||
4510 | return append_keyword_tzinfo(baserepr, self->tzinfo); | ||
4511 | } | ||
4512 | |||
4513 | static PyObject * | ||
4514 | datetime_str(PyDateTime_DateTime *self) | ||
4515 | { | ||
4516 | return PyObject_CallMethod((PyObject *)self, "isoformat", "(s)", " "); | ||
4517 | } | ||
4518 | |||
4519 | static PyObject * | ||
4520 | datetime_isoformat(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) | ||
4521 | { | ||
4522 | int sep = 'T'; | ||
4523 | static char *keywords[] = {"sep", NULL((void*)0)}; | ||
4524 | char buffer[100]; | ||
4525 | PyObject *result; | ||
4526 | int us = DATE_GET_MICROSECOND(self)((((PyDateTime_DateTime*)self)->data[7] << 16) | ((( PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]); | ||
4527 | |||
4528 | if (!PyArg_ParseTupleAndKeywords(args, kw, "|C:isoformat", keywords, &sep)) | ||
4529 | return NULL((void*)0); | ||
4530 | if (us) | ||
4531 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%04d-%02d-%02d%c%02d:%02d:%02d.%06d", | ||
4532 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
4533 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), (int)sep, | ||
4534 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4535 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6]), us); | ||
4536 | else | ||
4537 | result = PyUnicode_FromFormatPyUnicodeUCS2_FromFormat("%04d-%02d-%02d%c%02d:%02d:%02d", | ||
4538 | GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
4539 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), (int)sep, | ||
4540 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4541 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6])); | ||
4542 | |||
4543 | if (!result || !HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo)) | ||
4544 | return result; | ||
4545 | |||
4546 | /* We need to append the UTC offset. */ | ||
4547 | if (format_utcoffset(buffer, sizeof(buffer), ":", self->tzinfo, | ||
4548 | (PyObject *)self) < 0) { | ||
4549 | Py_DECREF(result)do { if (_Py_RefTotal-- , --((PyObject*)(result))->ob_refcnt != 0) { if (((PyObject*)result)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4549, (PyObject *)(result)); } else _Py_Dealloc((PyObject * )(result)); } while (0); | ||
4550 | return NULL((void*)0); | ||
4551 | } | ||
4552 | PyUnicode_AppendAndDelPyUnicodeUCS2_AppendAndDel(&result, PyUnicode_FromStringPyUnicodeUCS2_FromString(buffer)); | ||
4553 | return result; | ||
4554 | } | ||
4555 | |||
4556 | static PyObject * | ||
4557 | datetime_ctime(PyDateTime_DateTime *self) | ||
4558 | { | ||
4559 | return format_ctime((PyDateTime_Date *)self, | ||
4560 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), | ||
4561 | DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4562 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6])); | ||
4563 | } | ||
4564 | |||
4565 | /* Miscellaneous methods. */ | ||
4566 | |||
4567 | static PyObject * | ||
4568 | datetime_richcompare(PyObject *self, PyObject *other, int op) | ||
4569 | { | ||
4570 | PyObject *result = NULL((void*)0); | ||
4571 | PyObject *offset1, *offset2; | ||
4572 | int diff; | ||
4573 | |||
4574 | if (! PyDateTime_Check(other)((((PyObject*)(other))->ob_type) == (&PyDateTime_DateTimeType ) || PyType_IsSubtype((((PyObject*)(other))->ob_type), (& PyDateTime_DateTimeType)))) { | ||
4575 | if (PyDate_Check(other)((((PyObject*)(other))->ob_type) == (&PyDateTime_DateType ) || PyType_IsSubtype((((PyObject*)(other))->ob_type), (& PyDateTime_DateType)))) { | ||
4576 | /* Prevent invocation of date_richcompare. We want to | ||
4577 | return NotImplemented here to give the other object | ||
4578 | a chance. But since DateTime is a subclass of | ||
4579 | Date, if the other object is a Date, it would | ||
4580 | compute an ordering based on the date part alone, | ||
4581 | and we don't want that. So force unequal or | ||
4582 | uncomparable here in that case. */ | ||
4583 | if (op == Py_EQ2) | ||
4584 | Py_RETURN_FALSEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_FalseStruct )))->ob_refcnt++), ((PyObject *) &_Py_FalseStruct); | ||
4585 | if (op == Py_NE3) | ||
4586 | Py_RETURN_TRUEreturn ( _Py_RefTotal++ , ((PyObject*)(((PyObject *) &_Py_TrueStruct )))->ob_refcnt++), ((PyObject *) &_Py_TrueStruct); | ||
4587 | return cmperror(self, other); | ||
4588 | } | ||
4589 | Py_INCREF(Py_NotImplemented)( _Py_RefTotal++ , ((PyObject*)((&_Py_NotImplementedStruct )))->ob_refcnt++); | ||
4590 | return Py_NotImplemented(&_Py_NotImplementedStruct); | ||
4591 | } | ||
4592 | |||
4593 | if (GET_DT_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (&_Py_NoneStruct)) == GET_DT_TZINFO(other)((((_PyDateTime_BaseTZInfo *)(other))->hastzinfo) ? ((PyDateTime_DateTime *)(other))->tzinfo : (&_Py_NoneStruct))) { | ||
4594 | diff = memcmp(((PyDateTime_DateTime *)self)->data, | ||
4595 | ((PyDateTime_DateTime *)other)->data, | ||
4596 | _PyDateTime_DATETIME_DATASIZE10); | ||
4597 | return diff_to_bool(diff, op); | ||
4598 | } | ||
4599 | offset1 = datetime_utcoffset(self, NULL((void*)0)); | ||
4600 | if (offset1 == NULL((void*)0)) | ||
4601 | return NULL((void*)0); | ||
4602 | offset2 = datetime_utcoffset(other, NULL((void*)0)); | ||
4603 | if (offset2 == NULL((void*)0)) | ||
4604 | goto done; | ||
4605 | /* If they're both naive, or both aware and have the same offsets, | ||
4606 | * we get off cheap. Note that if they're both naive, offset1 == | ||
4607 | * offset2 == Py_None at this point. | ||
4608 | */ | ||
4609 | if ((offset1 == offset2) || | ||
4610 | (PyDelta_Check(offset1)((((PyObject*)(offset1))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(offset1))->ob_type), ( &PyDateTime_DeltaType))) && PyDelta_Check(offset2)((((PyObject*)(offset2))->ob_type) == (&PyDateTime_DeltaType ) || PyType_IsSubtype((((PyObject*)(offset2))->ob_type), ( &PyDateTime_DeltaType))) && | ||
4611 | delta_cmp(offset1, offset2) == 0)) { | ||
4612 | diff = memcmp(((PyDateTime_DateTime *)self)->data, | ||
4613 | ((PyDateTime_DateTime *)other)->data, | ||
4614 | _PyDateTime_DATETIME_DATASIZE10); | ||
4615 | result = diff_to_bool(diff, op); | ||
4616 | } | ||
4617 | else if (offset1 != Py_None(&_Py_NoneStruct) && offset2 != Py_None(&_Py_NoneStruct)) { | ||
4618 | PyDateTime_Delta *delta; | ||
4619 | |||
4620 | assert(offset1 != offset2)(__builtin_expect(!(offset1 != offset2), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4620, "offset1 != offset2") : (void)0); /* else last "if" handled it */ | ||
4621 | delta = (PyDateTime_Delta *)datetime_subtract((PyObject *)self, | ||
4622 | other); | ||
4623 | if (delta == NULL((void*)0)) | ||
4624 | goto done; | ||
4625 | diff = GET_TD_DAYS(delta)(((PyDateTime_Delta *)(delta))->days); | ||
4626 | if (diff == 0) | ||
4627 | diff = GET_TD_SECONDS(delta)(((PyDateTime_Delta *)(delta))->seconds) | | ||
4628 | GET_TD_MICROSECONDS(delta)(((PyDateTime_Delta *)(delta))->microseconds); | ||
4629 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4629, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
4630 | result = diff_to_bool(diff, op); | ||
4631 | } | ||
4632 | else { | ||
4633 | PyErr_SetString(PyExc_TypeError, | ||
4634 | "can't compare offset-naive and " | ||
4635 | "offset-aware datetimes"); | ||
4636 | } | ||
4637 | done: | ||
4638 | Py_DECREF(offset1)do { if (_Py_RefTotal-- , --((PyObject*)(offset1))->ob_refcnt != 0) { if (((PyObject*)offset1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4638, (PyObject *)(offset1)); } else _Py_Dealloc((PyObject * )(offset1)); } while (0); | ||
4639 | Py_XDECREF(offset2)do { if ((offset2) == ((void*)0)) ; else do { if (_Py_RefTotal -- , --((PyObject*)(offset2))->ob_refcnt != 0) { if (((PyObject *)offset2)->ob_refcnt < 0) _Py_NegativeRefcount("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4639, (PyObject *)(offset2)); } else _Py_Dealloc((PyObject * )(offset2)); } while (0); } while (0); | ||
4640 | return result; | ||
4641 | } | ||
4642 | |||
4643 | static Py_hash_t | ||
4644 | datetime_hash(PyDateTime_DateTime *self) | ||
4645 | { | ||
4646 | if (self->hashcode == -1) { | ||
4647 | PyObject *offset; | ||
4648 | |||
4649 | offset = datetime_utcoffset((PyObject *)self, NULL((void*)0)); | ||
4650 | |||
4651 | if (offset == NULL((void*)0)) | ||
4652 | return -1; | ||
4653 | |||
4654 | /* Reduce this to a hash of another object. */ | ||
4655 | if (offset == Py_None(&_Py_NoneStruct)) | ||
4656 | self->hashcode = generic_hash( | ||
4657 | (unsigned char *)self->data, _PyDateTime_DATETIME_DATASIZE10); | ||
4658 | else { | ||
4659 | PyObject *temp1, *temp2; | ||
4660 | int days, seconds; | ||
4661 | |||
4662 | assert(HASTZINFO(self))(__builtin_expect(!((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo )), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4662, "HASTZINFO(self)") : (void)0); | ||
4663 | days = ymd_to_ord(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), | ||
4664 | GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
4665 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3])); | ||
4666 | seconds = DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]) * 3600 + | ||
4667 | DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]) * 60 + | ||
4668 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6]); | ||
4669 | temp1 = new_delta(days, seconds,new_delta_ex(days, seconds, ((((PyDateTime_DateTime*)self)-> data[7] << 16) | (((PyDateTime_DateTime*)self)->data [8] << 8) | ((PyDateTime_DateTime*)self)->data[9]), 1 , &PyDateTime_DeltaType) | ||
4670 | DATE_GET_MICROSECOND(self),new_delta_ex(days, seconds, ((((PyDateTime_DateTime*)self)-> data[7] << 16) | (((PyDateTime_DateTime*)self)->data [8] << 8) | ((PyDateTime_DateTime*)self)->data[9]), 1 , &PyDateTime_DeltaType) | ||
4671 | 1)new_delta_ex(days, seconds, ((((PyDateTime_DateTime*)self)-> data[7] << 16) | (((PyDateTime_DateTime*)self)->data [8] << 8) | ((PyDateTime_DateTime*)self)->data[9]), 1 , &PyDateTime_DeltaType); | ||
4672 | if (temp1 == NULL((void*)0)) { | ||
4673 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4673, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4674 | return -1; | ||
4675 | } | ||
4676 | temp2 = delta_subtract(temp1, offset); | ||
4677 | Py_DECREF(temp1)do { if (_Py_RefTotal-- , --((PyObject*)(temp1))->ob_refcnt != 0) { if (((PyObject*)temp1)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4677, (PyObject *)(temp1)); } else _Py_Dealloc((PyObject *) (temp1)); } while (0); | ||
4678 | if (temp2 == NULL((void*)0)) { | ||
4679 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4679, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4680 | return -1; | ||
4681 | } | ||
4682 | self->hashcode = PyObject_Hash(temp2); | ||
4683 | Py_DECREF(temp2)do { if (_Py_RefTotal-- , --((PyObject*)(temp2))->ob_refcnt != 0) { if (((PyObject*)temp2)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4683, (PyObject *)(temp2)); } else _Py_Dealloc((PyObject *) (temp2)); } while (0); | ||
4684 | } | ||
4685 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4685, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4686 | } | ||
4687 | return self->hashcode; | ||
4688 | } | ||
4689 | |||
4690 | static PyObject * | ||
4691 | datetime_replace(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) | ||
4692 | { | ||
4693 | PyObject *clone; | ||
4694 | PyObject *tuple; | ||
4695 | int y = GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]); | ||
4696 | int m = GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]); | ||
4697 | int d = GET_DAY(self)(((PyDateTime_Date*)self)->data[3]); | ||
4698 | int hh = DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]); | ||
4699 | int mm = DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]); | ||
4700 | int ss = DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6]); | ||
4701 | int us = DATE_GET_MICROSECOND(self)((((PyDateTime_DateTime*)self)->data[7] << 16) | ((( PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]); | ||
4702 | PyObject *tzinfo = HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? self->tzinfo : Py_None(&_Py_NoneStruct); | ||
4703 | |||
4704 | if (! PyArg_ParseTupleAndKeywords(args, kw, "|iiiiiiiO:replace", | ||
4705 | datetime_kws, | ||
4706 | &y, &m, &d, &hh, &mm, &ss, &us, | ||
4707 | &tzinfo)) | ||
4708 | return NULL((void*)0); | ||
4709 | tuple = Py_BuildValue("iiiiiiiO", y, m, d, hh, mm, ss, us, tzinfo); | ||
4710 | if (tuple == NULL((void*)0)) | ||
4711 | return NULL((void*)0); | ||
4712 | clone = datetime_new(Py_TYPE(self)(((PyObject*)(self))->ob_type), tuple, NULL((void*)0)); | ||
4713 | Py_DECREF(tuple)do { if (_Py_RefTotal-- , --((PyObject*)(tuple))->ob_refcnt != 0) { if (((PyObject*)tuple)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4713, (PyObject *)(tuple)); } else _Py_Dealloc((PyObject *) (tuple)); } while (0); | ||
4714 | return clone; | ||
4715 | } | ||
4716 | |||
4717 | static PyObject * | ||
4718 | datetime_astimezone(PyDateTime_DateTime *self, PyObject *args, PyObject *kw) | ||
4719 | { | ||
4720 | PyObject *result; | ||
4721 | PyObject *offset; | ||
4722 | PyObject *temp; | ||
4723 | PyObject *tzinfo; | ||
4724 | static char *keywords[] = {"tz", NULL((void*)0)}; | ||
4725 | |||
4726 | if (! PyArg_ParseTupleAndKeywords(args, kw, "O!:astimezone", keywords, | ||
4727 | &PyDateTime_TZInfoType, &tzinfo)) | ||
4728 | return NULL((void*)0); | ||
4729 | |||
4730 | if (!HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) || self->tzinfo == Py_None(&_Py_NoneStruct)) | ||
4731 | goto NeedAware; | ||
4732 | |||
4733 | /* Conversion to self's own time zone is a NOP. */ | ||
4734 | if (self->tzinfo == tzinfo) { | ||
4735 | Py_INCREF(self)( _Py_RefTotal++ , ((PyObject*)(self))->ob_refcnt++); | ||
4736 | return (PyObject *)self; | ||
4737 | } | ||
4738 | |||
4739 | /* Convert self to UTC. */ | ||
4740 | offset = datetime_utcoffset((PyObject *)self, NULL((void*)0)); | ||
4741 | if (offset == NULL((void*)0)) | ||
4742 | return NULL((void*)0); | ||
4743 | if (offset == Py_None(&_Py_NoneStruct)) { | ||
4744 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4744, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4745 | NeedAware: | ||
4746 | PyErr_SetString(PyExc_ValueError, "astimezone() cannot be applied to " | ||
4747 | "a naive datetime"); | ||
4748 | return NULL((void*)0); | ||
4749 | } | ||
4750 | |||
4751 | /* result = self - offset */ | ||
4752 | result = add_datetime_timedelta(self, | ||
4753 | (PyDateTime_Delta *)offset, -1); | ||
4754 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4754, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4755 | if (result == NULL((void*)0)) | ||
4756 | return NULL((void*)0); | ||
4757 | |||
4758 | /* Attach new tzinfo and let fromutc() do the rest. */ | ||
4759 | temp = ((PyDateTime_DateTime *)result)->tzinfo; | ||
4760 | ((PyDateTime_DateTime *)result)->tzinfo = tzinfo; | ||
4761 | Py_INCREF(tzinfo)( _Py_RefTotal++ , ((PyObject*)(tzinfo))->ob_refcnt++); | ||
4762 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4762, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
4763 | |||
4764 | temp = result; | ||
4765 | result = PyObject_CallMethod(tzinfo, "fromutc", "O", temp); | ||
4766 | Py_DECREF(temp)do { if (_Py_RefTotal-- , --((PyObject*)(temp))->ob_refcnt != 0) { if (((PyObject*)temp)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4766, (PyObject *)(temp)); } else _Py_Dealloc((PyObject *)( temp)); } while (0); | ||
4767 | |||
4768 | return result; | ||
4769 | } | ||
4770 | |||
4771 | static PyObject * | ||
4772 | datetime_timetuple(PyDateTime_DateTime *self) | ||
4773 | { | ||
4774 | int dstflag = -1; | ||
4775 | |||
4776 | if (HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) && self->tzinfo != Py_None(&_Py_NoneStruct)) { | ||
4777 | PyObject * dst; | ||
4778 | |||
4779 | dst = call_dst(self->tzinfo, (PyObject *)self); | ||
4780 | if (dst == NULL((void*)0)) | ||
4781 | return NULL((void*)0); | ||
4782 | |||
4783 | if (dst != Py_None(&_Py_NoneStruct)) | ||
4784 | dstflag = delta_bool((PyDateTime_Delta *)dst); | ||
4785 | Py_DECREF(dst)do { if (_Py_RefTotal-- , --((PyObject*)(dst))->ob_refcnt != 0) { if (((PyObject*)dst)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4785, (PyObject *)(dst)); } else _Py_Dealloc((PyObject *)(dst )); } while (0); | ||
4786 | } | ||
4787 | return build_struct_time(GET_YEAR(self)((((PyDateTime_Date*)self)->data[0] << 8) | ((PyDateTime_Date *)self)->data[1]), | ||
4788 | GET_MONTH(self)(((PyDateTime_Date*)self)->data[2]), | ||
4789 | GET_DAY(self)(((PyDateTime_Date*)self)->data[3]), | ||
4790 | DATE_GET_HOUR(self)(((PyDateTime_DateTime*)self)->data[4]), | ||
4791 | DATE_GET_MINUTE(self)(((PyDateTime_DateTime*)self)->data[5]), | ||
4792 | DATE_GET_SECOND(self)(((PyDateTime_DateTime*)self)->data[6]), | ||
4793 | dstflag); | ||
4794 | } | ||
4795 | |||
4796 | static PyObject * | ||
4797 | datetime_getdate(PyDateTime_DateTime *self) | ||
4798 | { | ||
4799 | return new_date(GET_YEAR(self),new_date_ex(((((PyDateTime_Date*)self)->data[0] << 8 ) | ((PyDateTime_Date*)self)->data[1]), (((PyDateTime_Date *)self)->data[2]), (((PyDateTime_Date*)self)->data[3]), &PyDateTime_DateType) | ||
4800 | GET_MONTH(self),new_date_ex(((((PyDateTime_Date*)self)->data[0] << 8 ) | ((PyDateTime_Date*)self)->data[1]), (((PyDateTime_Date *)self)->data[2]), (((PyDateTime_Date*)self)->data[3]), &PyDateTime_DateType) | ||
4801 | GET_DAY(self))new_date_ex(((((PyDateTime_Date*)self)->data[0] << 8 ) | ((PyDateTime_Date*)self)->data[1]), (((PyDateTime_Date *)self)->data[2]), (((PyDateTime_Date*)self)->data[3]), &PyDateTime_DateType); | ||
4802 | } | ||
4803 | |||
4804 | static PyObject * | ||
4805 | datetime_gettime(PyDateTime_DateTime *self) | ||
4806 | { | ||
4807 | return new_time(DATE_GET_HOUR(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), (&_Py_NoneStruct), &PyDateTime_TimeType ) | ||
4808 | DATE_GET_MINUTE(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), (&_Py_NoneStruct), &PyDateTime_TimeType ) | ||
4809 | DATE_GET_SECOND(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), (&_Py_NoneStruct), &PyDateTime_TimeType ) | ||
4810 | DATE_GET_MICROSECOND(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), (&_Py_NoneStruct), &PyDateTime_TimeType ) | ||
4811 | Py_None)new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), (&_Py_NoneStruct), &PyDateTime_TimeType ); | ||
4812 | } | ||
4813 | |||
4814 | static PyObject * | ||
4815 | datetime_gettimetz(PyDateTime_DateTime *self) | ||
4816 | { | ||
4817 | return new_time(DATE_GET_HOUR(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), ((((_PyDateTime_BaseTZInfo *)(self))-> hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (& _Py_NoneStruct)), &PyDateTime_TimeType) | ||
4818 | DATE_GET_MINUTE(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), ((((_PyDateTime_BaseTZInfo *)(self))-> hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (& _Py_NoneStruct)), &PyDateTime_TimeType) | ||
4819 | DATE_GET_SECOND(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), ((((_PyDateTime_BaseTZInfo *)(self))-> hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (& _Py_NoneStruct)), &PyDateTime_TimeType) | ||
4820 | DATE_GET_MICROSECOND(self),new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), ((((_PyDateTime_BaseTZInfo *)(self))-> hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (& _Py_NoneStruct)), &PyDateTime_TimeType) | ||
4821 | GET_DT_TZINFO(self))new_time_ex((((PyDateTime_DateTime*)self)->data[4]), (((PyDateTime_DateTime *)self)->data[5]), (((PyDateTime_DateTime*)self)->data[ 6]), ((((PyDateTime_DateTime*)self)->data[7] << 16) | (((PyDateTime_DateTime*)self)->data[8] << 8) | ((PyDateTime_DateTime *)self)->data[9]), ((((_PyDateTime_BaseTZInfo *)(self))-> hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (& _Py_NoneStruct)), &PyDateTime_TimeType); | ||
4822 | } | ||
4823 | |||
4824 | static PyObject * | ||
4825 | datetime_utctimetuple(PyDateTime_DateTime *self) | ||
4826 | { | ||
4827 | int y, m, d, hh, mm, ss; | ||
4828 | PyObject *tzinfo; | ||
4829 | PyDateTime_DateTime *utcself; | ||
4830 | |||
4831 | tzinfo = GET_DT_TZINFO(self)((((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) ? ((PyDateTime_DateTime *)(self))->tzinfo : (&_Py_NoneStruct)); | ||
4832 | if (tzinfo == Py_None(&_Py_NoneStruct)) { | ||
4833 | utcself = self; | ||
4834 | Py_INCREF(utcself)( _Py_RefTotal++ , ((PyObject*)(utcself))->ob_refcnt++); | ||
4835 | } | ||
4836 | else { | ||
4837 | PyObject *offset; | ||
4838 | offset = call_utcoffset(tzinfo, (PyObject *)self); | ||
4839 | if (offset == NULL((void*)0)) | ||
4840 | return NULL((void*)0); | ||
4841 | if (offset == Py_None(&_Py_NoneStruct)) { | ||
4842 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4842, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4843 | utcself = self; | ||
4844 | Py_INCREF(utcself)( _Py_RefTotal++ , ((PyObject*)(utcself))->ob_refcnt++); | ||
4845 | } | ||
4846 | else { | ||
4847 | utcself = (PyDateTime_DateTime *)add_datetime_timedelta(self, | ||
4848 | (PyDateTime_Delta *)offset, -1); | ||
4849 | Py_DECREF(offset)do { if (_Py_RefTotal-- , --((PyObject*)(offset))->ob_refcnt != 0) { if (((PyObject*)offset)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4849, (PyObject *)(offset)); } else _Py_Dealloc((PyObject * )(offset)); } while (0); | ||
4850 | if (utcself == NULL((void*)0)) | ||
4851 | return NULL((void*)0); | ||
4852 | } | ||
4853 | } | ||
4854 | y = GET_YEAR(utcself)((((PyDateTime_Date*)utcself)->data[0] << 8) | ((PyDateTime_Date *)utcself)->data[1]); | ||
4855 | m = GET_MONTH(utcself)(((PyDateTime_Date*)utcself)->data[2]); | ||
4856 | d = GET_DAY(utcself)(((PyDateTime_Date*)utcself)->data[3]); | ||
4857 | hh = DATE_GET_HOUR(utcself)(((PyDateTime_DateTime*)utcself)->data[4]); | ||
4858 | mm = DATE_GET_MINUTE(utcself)(((PyDateTime_DateTime*)utcself)->data[5]); | ||
4859 | ss = DATE_GET_SECOND(utcself)(((PyDateTime_DateTime*)utcself)->data[6]); | ||
4860 | |||
4861 | Py_DECREF(utcself)do { if (_Py_RefTotal-- , --((PyObject*)(utcself))->ob_refcnt != 0) { if (((PyObject*)utcself)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4861, (PyObject *)(utcself)); } else _Py_Dealloc((PyObject * )(utcself)); } while (0); | ||
4862 | return build_struct_time(y, m, d, hh, mm, ss, 0); | ||
4863 | } | ||
4864 | |||
4865 | /* Pickle support, a simple use of __reduce__. */ | ||
4866 | |||
4867 | /* Let basestate be the non-tzinfo data string. | ||
4868 | * If tzinfo is None, this returns (basestate,), else (basestate, tzinfo). | ||
4869 | * So it's a tuple in any (non-error) case. | ||
4870 | * __getstate__ isn't exposed. | ||
4871 | */ | ||
4872 | static PyObject * | ||
4873 | datetime_getstate(PyDateTime_DateTime *self) | ||
4874 | { | ||
4875 | PyObject *basestate; | ||
4876 | PyObject *result = NULL((void*)0); | ||
4877 | |||
4878 | basestate = PyBytes_FromStringAndSize((char *)self->data, | ||
4879 | _PyDateTime_DATETIME_DATASIZE10); | ||
4880 | if (basestate != NULL((void*)0)) { | ||
4881 | if (! HASTZINFO(self)(((_PyDateTime_BaseTZInfo *)(self))->hastzinfo) || self->tzinfo == Py_None(&_Py_NoneStruct)) | ||
4882 | result = PyTuple_Pack(1, basestate); | ||
4883 | else | ||
4884 | result = PyTuple_Pack(2, basestate, self->tzinfo); | ||
4885 | Py_DECREF(basestate)do { if (_Py_RefTotal-- , --((PyObject*)(basestate))->ob_refcnt != 0) { if (((PyObject*)basestate)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 4885, (PyObject *)(basestate)); } else _Py_Dealloc((PyObject *)(basestate)); } while (0); | ||
4886 | } | ||
4887 | return result; | ||
4888 | } | ||
4889 | |||
4890 | static PyObject * | ||
4891 | datetime_reduce(PyDateTime_DateTime *self, PyObject *arg) | ||
4892 | { | ||
4893 | return Py_BuildValue("(ON)", Py_TYPE(self)(((PyObject*)(self))->ob_type), datetime_getstate(self)); | ||
4894 | } | ||
4895 | |||
4896 | static PyMethodDef datetime_methods[] = { | ||
4897 | |||
4898 | /* Class methods: */ | ||
4899 | |||
4900 | {"now", (PyCFunction)datetime_now, | ||
4901 | METH_VARARGS0x0001 | METH_KEYWORDS0x0002 | METH_CLASS0x0010, | ||
4902 | PyDoc_STR("[tz] -> new datetime with tz's local day and time.")"[tz] -> new datetime with tz's local day and time."}, | ||
4903 | |||
4904 | {"utcnow", (PyCFunction)datetime_utcnow, | ||
4905 | METH_NOARGS0x0004 | METH_CLASS0x0010, | ||
4906 | PyDoc_STR("Return a new datetime representing UTC day and time.")"Return a new datetime representing UTC day and time."}, | ||
4907 | |||
4908 | {"fromtimestamp", (PyCFunction)datetime_fromtimestamp, | ||
4909 | METH_VARARGS0x0001 | METH_KEYWORDS0x0002 | METH_CLASS0x0010, | ||
4910 | PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")"timestamp[, tz] -> tz's local time from POSIX timestamp."}, | ||
4911 | |||
4912 | {"utcfromtimestamp", (PyCFunction)datetime_utcfromtimestamp, | ||
4913 | METH_VARARGS0x0001 | METH_CLASS0x0010, | ||
4914 | PyDoc_STR("timestamp -> UTC datetime from a POSIX timestamp ""timestamp -> UTC datetime from a POSIX timestamp " "(like time.time())." | ||
4915 | "(like time.time()).")"timestamp -> UTC datetime from a POSIX timestamp " "(like time.time())."}, | ||
4916 | |||
4917 | {"strptime", (PyCFunction)datetime_strptime, | ||
4918 | METH_VARARGS0x0001 | METH_CLASS0x0010, | ||
4919 | PyDoc_STR("string, format -> new datetime parsed from a string ""string, format -> new datetime parsed from a string " "(like time.strptime())." | ||
4920 | "(like time.strptime()).")"string, format -> new datetime parsed from a string " "(like time.strptime())."}, | ||
4921 | |||
4922 | {"combine", (PyCFunction)datetime_combine, | ||
4923 | METH_VARARGS0x0001 | METH_KEYWORDS0x0002 | METH_CLASS0x0010, | ||
4924 | PyDoc_STR("date, time -> datetime with same date and time fields")"date, time -> datetime with same date and time fields"}, | ||
4925 | |||
4926 | /* Instance methods: */ | ||
4927 | |||
4928 | {"date", (PyCFunction)datetime_getdate, METH_NOARGS0x0004, | ||
4929 | PyDoc_STR("Return date object with same year, month and day.")"Return date object with same year, month and day."}, | ||
4930 | |||
4931 | {"time", (PyCFunction)datetime_gettime, METH_NOARGS0x0004, | ||
4932 | PyDoc_STR("Return time object with same time but with tzinfo=None.")"Return time object with same time but with tzinfo=None."}, | ||
4933 | |||
4934 | {"timetz", (PyCFunction)datetime_gettimetz, METH_NOARGS0x0004, | ||
4935 | PyDoc_STR("Return time object with same time and tzinfo.")"Return time object with same time and tzinfo."}, | ||
4936 | |||
4937 | {"ctime", (PyCFunction)datetime_ctime, METH_NOARGS0x0004, | ||
4938 | PyDoc_STR("Return ctime() style string.")"Return ctime() style string."}, | ||
4939 | |||
4940 | {"timetuple", (PyCFunction)datetime_timetuple, METH_NOARGS0x0004, | ||
4941 | PyDoc_STR("Return time tuple, compatible with time.localtime().")"Return time tuple, compatible with time.localtime()."}, | ||
4942 | |||
4943 | {"utctimetuple", (PyCFunction)datetime_utctimetuple, METH_NOARGS0x0004, | ||
4944 | PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")"Return UTC time tuple, compatible with time.localtime()."}, | ||
4945 | |||
4946 | {"isoformat", (PyCFunction)datetime_isoformat, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
4947 | PyDoc_STR("[sep] -> string in ISO 8601 format, ""[sep] -> string in ISO 8601 format, " "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n" "sep is used to separate the year from the time, and " "defaults to 'T'." | ||
4948 | "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n""[sep] -> string in ISO 8601 format, " "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n" "sep is used to separate the year from the time, and " "defaults to 'T'." | ||
4949 | "sep is used to separate the year from the time, and ""[sep] -> string in ISO 8601 format, " "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n" "sep is used to separate the year from the time, and " "defaults to 'T'." | ||
4950 | "defaults to 'T'.")"[sep] -> string in ISO 8601 format, " "YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].\n\n" "sep is used to separate the year from the time, and " "defaults to 'T'."}, | ||
4951 | |||
4952 | {"utcoffset", (PyCFunction)datetime_utcoffset, METH_NOARGS0x0004, | ||
4953 | PyDoc_STR("Return self.tzinfo.utcoffset(self).")"Return self.tzinfo.utcoffset(self)."}, | ||
4954 | |||
4955 | {"tzname", (PyCFunction)datetime_tzname, METH_NOARGS0x0004, | ||
4956 | PyDoc_STR("Return self.tzinfo.tzname(self).")"Return self.tzinfo.tzname(self)."}, | ||
4957 | |||
4958 | {"dst", (PyCFunction)datetime_dst, METH_NOARGS0x0004, | ||
4959 | PyDoc_STR("Return self.tzinfo.dst(self).")"Return self.tzinfo.dst(self)."}, | ||
4960 | |||
4961 | {"replace", (PyCFunction)datetime_replace, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
4962 | PyDoc_STR("Return datetime with new specified fields.")"Return datetime with new specified fields."}, | ||
4963 | |||
4964 | {"astimezone", (PyCFunction)datetime_astimezone, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, | ||
4965 | PyDoc_STR("tz -> convert to local time in new timezone tz\n")"tz -> convert to local time in new timezone tz\n"}, | ||
4966 | |||
4967 | {"__reduce__", (PyCFunction)datetime_reduce, METH_NOARGS0x0004, | ||
4968 | PyDoc_STR("__reduce__() -> (cls, state)")"__reduce__() -> (cls, state)"}, | ||
4969 | |||
4970 | {NULL((void*)0), NULL((void*)0)} | ||
4971 | }; | ||
4972 | |||
4973 | static char datetime_doc[] = | ||
4974 | PyDoc_STR("datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\"datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
4975 | \n\"datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
4976 | The year, month and day arguments are required. tzinfo may be None, or an\n\"datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints or longs.\n" | ||
4977 | instance of a tzinfo subclass. The remaining arguments may be ints or longs.\n")"datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints or longs.\n"; | ||
4978 | |||
4979 | static PyNumberMethods datetime_as_number = { | ||
4980 | datetime_add, /* nb_add */ | ||
4981 | datetime_subtract, /* nb_subtract */ | ||
4982 | 0, /* nb_multiply */ | ||
4983 | 0, /* nb_remainder */ | ||
4984 | 0, /* nb_divmod */ | ||
4985 | 0, /* nb_power */ | ||
4986 | 0, /* nb_negative */ | ||
4987 | 0, /* nb_positive */ | ||
4988 | 0, /* nb_absolute */ | ||
4989 | 0, /* nb_bool */ | ||
4990 | }; | ||
4991 | |||
4992 | static PyTypeObject PyDateTime_DateTimeType = { | ||
4993 | PyVarObject_HEAD_INIT(NULL, 0){ { 0, 0, 1, ((void*)0) }, 0 }, | ||
4994 | "datetime.datetime", /* tp_name */ | ||
4995 | sizeof(PyDateTime_DateTime), /* tp_basicsize */ | ||
4996 | 0, /* tp_itemsize */ | ||
4997 | (destructor)datetime_dealloc, /* tp_dealloc */ | ||
4998 | 0, /* tp_print */ | ||
4999 | 0, /* tp_getattr */ | ||
5000 | 0, /* tp_setattr */ | ||
5001 | 0, /* tp_reserved */ | ||
5002 | (reprfunc)datetime_repr, /* tp_repr */ | ||
5003 | &datetime_as_number, /* tp_as_number */ | ||
5004 | 0, /* tp_as_sequence */ | ||
5005 | 0, /* tp_as_mapping */ | ||
5006 | (hashfunc)datetime_hash, /* tp_hash */ | ||
5007 | 0, /* tp_call */ | ||
5008 | (reprfunc)datetime_str, /* tp_str */ | ||
5009 | PyObject_GenericGetAttr, /* tp_getattro */ | ||
5010 | 0, /* tp_setattro */ | ||
5011 | 0, /* tp_as_buffer */ | ||
5012 | Py_TPFLAGS_DEFAULT( 0 | (1L<<18) | 0) | Py_TPFLAGS_BASETYPE(1L<<10), /* tp_flags */ | ||
5013 | datetime_doc, /* tp_doc */ | ||
5014 | 0, /* tp_traverse */ | ||
5015 | 0, /* tp_clear */ | ||
5016 | datetime_richcompare, /* tp_richcompare */ | ||
5017 | 0, /* tp_weaklistoffset */ | ||
5018 | 0, /* tp_iter */ | ||
5019 | 0, /* tp_iternext */ | ||
5020 | datetime_methods, /* tp_methods */ | ||
5021 | 0, /* tp_members */ | ||
5022 | datetime_getset, /* tp_getset */ | ||
5023 | &PyDateTime_DateType, /* tp_base */ | ||
5024 | 0, /* tp_dict */ | ||
5025 | 0, /* tp_descr_get */ | ||
5026 | 0, /* tp_descr_set */ | ||
5027 | 0, /* tp_dictoffset */ | ||
5028 | 0, /* tp_init */ | ||
5029 | datetime_alloc, /* tp_alloc */ | ||
5030 | datetime_new, /* tp_new */ | ||
5031 | 0, /* tp_free */ | ||
5032 | }; | ||
5033 | |||
5034 | /* --------------------------------------------------------------------------- | ||
5035 | * Module methods and initialization. | ||
5036 | */ | ||
5037 | |||
5038 | static PyMethodDef module_methods[] = { | ||
5039 | {NULL((void*)0), NULL((void*)0)} | ||
5040 | }; | ||
5041 | |||
5042 | /* C API. Clients get at this via PyDateTime_IMPORT, defined in | ||
5043 | * datetime.h. | ||
5044 | */ | ||
5045 | static PyDateTime_CAPI CAPI = { | ||
5046 | &PyDateTime_DateType, | ||
5047 | &PyDateTime_DateTimeType, | ||
5048 | &PyDateTime_TimeType, | ||
5049 | &PyDateTime_DeltaType, | ||
5050 | &PyDateTime_TZInfoType, | ||
5051 | new_date_ex, | ||
5052 | new_datetime_ex, | ||
5053 | new_time_ex, | ||
5054 | new_delta_ex, | ||
5055 | datetime_fromtimestamp, | ||
5056 | date_fromtimestamp | ||
5057 | }; | ||
5058 | |||
5059 | |||
5060 | |||
5061 | static struct PyModuleDef datetimemodule = { | ||
5062 | PyModuleDef_HEAD_INIT{ { 0, 0, 1, ((void*)0) }, ((void*)0), 0, ((void*)0), }, | ||
5063 | "_datetime", | ||
5064 | "Fast implementation of the datetime type.", | ||
5065 | -1, | ||
5066 | module_methods, | ||
5067 | NULL((void*)0), | ||
5068 | NULL((void*)0), | ||
5069 | NULL((void*)0), | ||
5070 | NULL((void*)0) | ||
5071 | }; | ||
5072 | |||
5073 | PyMODINIT_FUNCPyObject* | ||
5074 | PyInit__datetime(void) | ||
5075 | { | ||
5076 | PyObject *m; /* a module object */ | ||
5077 | PyObject *d; /* its dict */ | ||
5078 | PyObject *x; | ||
5079 | PyObject *delta; | ||
5080 | |||
5081 | m = PyModule_Create(&datetimemodule)PyModule_Create2TraceRefs(&datetimemodule, 1013); | ||
5082 | if (m == NULL((void*)0)) | ||
5083 | return NULL((void*)0); | ||
5084 | |||
5085 | if (PyType_Ready(&PyDateTime_DateType) < 0) | ||
5086 | return NULL((void*)0); | ||
5087 | if (PyType_Ready(&PyDateTime_DateTimeType) < 0) | ||
5088 | return NULL((void*)0); | ||
5089 | if (PyType_Ready(&PyDateTime_DeltaType) < 0) | ||
5090 | return NULL((void*)0); | ||
5091 | if (PyType_Ready(&PyDateTime_TimeType) < 0) | ||
5092 | return NULL((void*)0); | ||
5093 | if (PyType_Ready(&PyDateTime_TZInfoType) < 0) | ||
5094 | return NULL((void*)0); | ||
5095 | if (PyType_Ready(&PyDateTime_TimeZoneType) < 0) | ||
5096 | return NULL((void*)0); | ||
5097 | |||
5098 | /* timedelta values */ | ||
5099 | d = PyDateTime_DeltaType.tp_dict; | ||
5100 | |||
5101 | x = new_delta(0, 0, 1, 0)new_delta_ex(0, 0, 1, 0, &PyDateTime_DeltaType); | ||
5102 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "resolution", x) < 0) | ||
5103 | return NULL((void*)0); | ||
5104 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5104, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5105 | |||
5106 | x = new_delta(-MAX_DELTA_DAYS, 0, 0, 0)new_delta_ex(-999999999, 0, 0, 0, &PyDateTime_DeltaType); | ||
5107 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "min", x) < 0) | ||
5108 | return NULL((void*)0); | ||
5109 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5109, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5110 | |||
5111 | x = new_delta(MAX_DELTA_DAYS, 24*3600-1, 1000000-1, 0)new_delta_ex(999999999, 24*3600 -1, 1000000 -1, 0, &PyDateTime_DeltaType ); | ||
5112 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "max", x) < 0) | ||
5113 | return NULL((void*)0); | ||
5114 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5114, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5115 | |||
5116 | /* date values */ | ||
5117 | d = PyDateTime_DateType.tp_dict; | ||
5118 | |||
5119 | x = new_date(1, 1, 1)new_date_ex(1, 1, 1, &PyDateTime_DateType); | ||
5120 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "min", x) < 0) | ||
5121 | return NULL((void*)0); | ||
5122 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5122, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5123 | |||
5124 | x = new_date(MAXYEAR, 12, 31)new_date_ex(9999, 12, 31, &PyDateTime_DateType); | ||
5125 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "max", x) < 0) | ||
5126 | return NULL((void*)0); | ||
5127 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5127, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5128 | |||
5129 | x = new_delta(1, 0, 0, 0)new_delta_ex(1, 0, 0, 0, &PyDateTime_DeltaType); | ||
5130 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "resolution", x) < 0) | ||
5131 | return NULL((void*)0); | ||
5132 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5132, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5133 | |||
5134 | /* time values */ | ||
5135 | d = PyDateTime_TimeType.tp_dict; | ||
5136 | |||
5137 | x = new_time(0, 0, 0, 0, Py_None)new_time_ex(0, 0, 0, 0, (&_Py_NoneStruct), &PyDateTime_TimeType ); | ||
5138 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "min", x) < 0) | ||
5139 | return NULL((void*)0); | ||
5140 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5140, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5141 | |||
5142 | x = new_time(23, 59, 59, 999999, Py_None)new_time_ex(23, 59, 59, 999999, (&_Py_NoneStruct), &PyDateTime_TimeType ); | ||
5143 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "max", x) < 0) | ||
5144 | return NULL((void*)0); | ||
5145 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5145, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5146 | |||
5147 | x = new_delta(0, 0, 1, 0)new_delta_ex(0, 0, 1, 0, &PyDateTime_DeltaType); | ||
5148 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "resolution", x) < 0) | ||
5149 | return NULL((void*)0); | ||
5150 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5150, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5151 | |||
5152 | /* datetime values */ | ||
5153 | d = PyDateTime_DateTimeType.tp_dict; | ||
5154 | |||
5155 | x = new_datetime(1, 1, 1, 0, 0, 0, 0, Py_None)new_datetime_ex(1, 1, 1, 0, 0, 0, 0, (&_Py_NoneStruct), & PyDateTime_DateTimeType); | ||
5156 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "min", x) < 0) | ||
5157 | return NULL((void*)0); | ||
5158 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5158, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5159 | |||
5160 | x = new_datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, Py_None)new_datetime_ex(9999, 12, 31, 23, 59, 59, 999999, (&_Py_NoneStruct ), &PyDateTime_DateTimeType); | ||
5161 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "max", x) < 0) | ||
5162 | return NULL((void*)0); | ||
5163 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5163, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5164 | |||
5165 | x = new_delta(0, 0, 1, 0)new_delta_ex(0, 0, 1, 0, &PyDateTime_DeltaType); | ||
5166 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "resolution", x) < 0) | ||
5167 | return NULL((void*)0); | ||
5168 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5168, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5169 | |||
5170 | /* timezone values */ | ||
5171 | d = PyDateTime_TimeZoneType.tp_dict; | ||
5172 | |||
5173 | delta = new_delta(0, 0, 0, 0)new_delta_ex(0, 0, 0, 0, &PyDateTime_DeltaType); | ||
5174 | if (delta == NULL((void*)0)) | ||
5175 | return NULL((void*)0); | ||
5176 | x = create_timezone(delta, NULL((void*)0)); | ||
5177 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5177, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
5178 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "utc", x) < 0) | ||
5179 | return NULL((void*)0); | ||
5180 | PyDateTime_TimeZone_UTC = x; | ||
5181 | |||
5182 | delta = new_delta(-1, 60, 0, 1)new_delta_ex(-1, 60, 0, 1, &PyDateTime_DeltaType); /* -23:59 */ | ||
5183 | if (delta == NULL((void*)0)) | ||
5184 | return NULL((void*)0); | ||
5185 | x = create_timezone(delta, NULL((void*)0)); | ||
5186 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5186, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
5187 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "min", x) < 0) | ||
5188 | return NULL((void*)0); | ||
5189 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5189, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5190 | |||
5191 | delta = new_delta(0, (23 * 60 + 59) * 60, 0, 0)new_delta_ex(0, (23 * 60 + 59) * 60, 0, 0, &PyDateTime_DeltaType ); /* +23:59 */ | ||
5192 | if (delta == NULL((void*)0)) | ||
5193 | return NULL((void*)0); | ||
5194 | x = create_timezone(delta, NULL((void*)0)); | ||
5195 | Py_DECREF(delta)do { if (_Py_RefTotal-- , --((PyObject*)(delta))->ob_refcnt != 0) { if (((PyObject*)delta)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5195, (PyObject *)(delta)); } else _Py_Dealloc((PyObject *) (delta)); } while (0); | ||
5196 | if (x == NULL((void*)0) || PyDict_SetItemString(d, "max", x) < 0) | ||
5197 | return NULL((void*)0); | ||
5198 | Py_DECREF(x)do { if (_Py_RefTotal-- , --((PyObject*)(x))->ob_refcnt != 0) { if (((PyObject*)x)->ob_refcnt < 0) _Py_NegativeRefcount ("/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5198, (PyObject *)(x)); } else _Py_Dealloc((PyObject *)(x)) ; } while (0); | ||
5199 | |||
5200 | /* module initialization */ | ||
5201 | PyModule_AddIntConstant(m, "MINYEAR", MINYEAR1); | ||
5202 | PyModule_AddIntConstant(m, "MAXYEAR", MAXYEAR9999); | ||
5203 | |||
5204 | Py_INCREF(&PyDateTime_DateType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_DateType))-> ob_refcnt++); | ||
5205 | PyModule_AddObject(m, "date", (PyObject *) &PyDateTime_DateType); | ||
5206 | |||
5207 | Py_INCREF(&PyDateTime_DateTimeType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_DateTimeType) )->ob_refcnt++); | ||
5208 | PyModule_AddObject(m, "datetime", | ||
5209 | (PyObject *)&PyDateTime_DateTimeType); | ||
5210 | |||
5211 | Py_INCREF(&PyDateTime_TimeType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_TimeType))-> ob_refcnt++); | ||
5212 | PyModule_AddObject(m, "time", (PyObject *) &PyDateTime_TimeType); | ||
5213 | |||
5214 | Py_INCREF(&PyDateTime_DeltaType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_DeltaType))-> ob_refcnt++); | ||
5215 | PyModule_AddObject(m, "timedelta", (PyObject *) &PyDateTime_DeltaType); | ||
5216 | |||
5217 | Py_INCREF(&PyDateTime_TZInfoType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_TZInfoType))-> ob_refcnt++); | ||
5218 | PyModule_AddObject(m, "tzinfo", (PyObject *) &PyDateTime_TZInfoType); | ||
5219 | |||
5220 | Py_INCREF(&PyDateTime_TimeZoneType)( _Py_RefTotal++ , ((PyObject*)(&PyDateTime_TimeZoneType) )->ob_refcnt++); | ||
5221 | PyModule_AddObject(m, "timezone", (PyObject *) &PyDateTime_TimeZoneType); | ||
5222 | |||
5223 | x = PyCapsule_New(&CAPI, PyDateTime_CAPSULE_NAME"datetime.datetime_CAPI", NULL((void*)0)); | ||
5224 | if (x == NULL((void*)0)) | ||
5225 | return NULL((void*)0); | ||
5226 | PyModule_AddObject(m, "datetime_CAPI", x); | ||
5227 | |||
5228 | /* A 4-year cycle has an extra leap day over what we'd get from | ||
5229 | * pasting together 4 single years. | ||
5230 | */ | ||
5231 | assert(DI4Y == 4 * 365 + 1)(__builtin_expect(!(1461 == 4 * 365 + 1), 0) ? __assert_rtn(__func__ , "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5231, "DI4Y == 4 * 365 + 1") : (void)0); | ||
5232 | assert(DI4Y == days_before_year(4+1))(__builtin_expect(!(1461 == days_before_year(4 +1)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5232, "DI4Y == days_before_year(4+1)") : (void)0); | ||
5233 | |||
5234 | /* Similarly, a 400-year cycle has an extra leap day over what we'd | ||
5235 | * get from pasting together 4 100-year cycles. | ||
5236 | */ | ||
5237 | assert(DI400Y == 4 * DI100Y + 1)(__builtin_expect(!(146097 == 4 * 36524 + 1), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5237, "DI400Y == 4 * DI100Y + 1") : (void)0); | ||
5238 | assert(DI400Y == days_before_year(400+1))(__builtin_expect(!(146097 == days_before_year(400 +1)), 0) ? __assert_rtn(__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5238, "DI400Y == days_before_year(400+1)") : (void)0); | ||
5239 | |||
5240 | /* OTOH, a 100-year cycle has one fewer leap day than we'd get from | ||
5241 | * pasting together 25 4-year cycles. | ||
5242 | */ | ||
5243 | assert(DI100Y == 25 * DI4Y - 1)(__builtin_expect(!(36524 == 25 * 1461 - 1), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5243, "DI100Y == 25 * DI4Y - 1") : (void)0); | ||
5244 | assert(DI100Y == days_before_year(100+1))(__builtin_expect(!(36524 == days_before_year(100 +1)), 0) ? __assert_rtn (__func__, "/Users/brett/Dev/python/3.x/py3k/Modules/_datetimemodule.c" , 5244, "DI100Y == days_before_year(100+1)") : (void)0); | ||
5245 | |||
5246 | us_per_us = PyLong_FromLong(1); | ||
5247 | us_per_ms = PyLong_FromLong(1000); | ||
5248 | us_per_second = PyLong_FromLong(1000000); | ||
5249 | us_per_minute = PyLong_FromLong(60000000); | ||
5250 | seconds_per_day = PyLong_FromLong(24 * 3600); | ||
5251 | if (us_per_us == NULL((void*)0) || us_per_ms == NULL((void*)0) || us_per_second == NULL((void*)0) || | ||
5252 | us_per_minute == NULL((void*)0) || seconds_per_day == NULL((void*)0)) | ||
5253 | return NULL((void*)0); | ||
5254 | |||
5255 | /* The rest are too big for 32-bit ints, but even | ||
5256 | * us_per_week fits in 40 bits, so doubles should be exact. | ||
5257 | */ | ||
5258 | us_per_hour = PyLong_FromDouble(3600000000.0); | ||
5259 | us_per_day = PyLong_FromDouble(86400000000.0); | ||
5260 | us_per_week = PyLong_FromDouble(604800000000.0); | ||
5261 | if (us_per_hour == NULL((void*)0) || us_per_day == NULL((void*)0) || us_per_week == NULL((void*)0)) | ||
5262 | return NULL((void*)0); | ||
5263 | return m; | ||
5264 | } | ||
5265 | |||
5266 | /* --------------------------------------------------------------------------- | ||
5267 | Some time zone algebra. For a datetime x, let | ||
5268 | x.n = x stripped of its timezone -- its naive time. | ||
5269 | x.o = x.utcoffset(), and assuming that doesn't raise an exception or | ||
5270 | return None | ||
5271 | x.d = x.dst(), and assuming that doesn't raise an exception or | ||
5272 | return None | ||
5273 | x.s = x's standard offset, x.o - x.d | ||
5274 | |||
5275 | Now some derived rules, where k is a duration (timedelta). | ||
5276 | |||
5277 | 1. x.o = x.s + x.d | ||
5278 | This follows from the definition of x.s. | ||
5279 | |||
5280 | 2. If x and y have the same tzinfo member, x.s = y.s. | ||
5281 | This is actually a requirement, an assumption we need to make about | ||
5282 | sane tzinfo classes. | ||
5283 | |||
5284 | 3. The naive UTC time corresponding to x is x.n - x.o. | ||
5285 | This is again a requirement for a sane tzinfo class. | ||
5286 | |||
5287 | 4. (x+k).s = x.s | ||
5288 | This follows from #2, and that datimetimetz+timedelta preserves tzinfo. | ||
5289 | |||
5290 | 5. (x+k).n = x.n + k | ||
5291 | Again follows from how arithmetic is defined. | ||
5292 | |||
5293 | Now we can explain tz.fromutc(x). Let's assume it's an interesting case | ||
5294 | (meaning that the various tzinfo methods exist, and don't blow up or return | ||
5295 | None when called). | ||
5296 | |||
5297 | The function wants to return a datetime y with timezone tz, equivalent to x. | ||
5298 | x is already in UTC. | ||
5299 | |||
5300 | By #3, we want | ||
5301 | |||
5302 | y.n - y.o = x.n [1] | ||
5303 | |||
5304 | The algorithm starts by attaching tz to x.n, and calling that y. So | ||
5305 | x.n = y.n at the start. Then it wants to add a duration k to y, so that [1] | ||
5306 | becomes true; in effect, we want to solve [2] for k: | ||
5307 | |||
5308 | (y+k).n - (y+k).o = x.n [2] | ||
5309 | |||
5310 | By #1, this is the same as | ||
5311 | |||
5312 | (y+k).n - ((y+k).s + (y+k).d) = x.n [3] | ||
5313 | |||
5314 | By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start. | ||
5315 | Substituting that into [3], | ||
5316 | |||
5317 | x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving | ||
5318 | k - (y+k).s - (y+k).d = 0; rearranging, | ||
5319 | k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so | ||
5320 | k = y.s - (y+k).d | ||
5321 | |||
5322 | On the RHS, (y+k).d can't be computed directly, but y.s can be, and we | ||
5323 | approximate k by ignoring the (y+k).d term at first. Note that k can't be | ||
5324 | very large, since all offset-returning methods return a duration of magnitude | ||
5325 | less than 24 hours. For that reason, if y is firmly in std time, (y+k).d must | ||
5326 | be 0, so ignoring it has no consequence then. | ||
5327 | |||
5328 | In any case, the new value is | ||
5329 | |||
5330 | z = y + y.s [4] | ||
5331 | |||
5332 | It's helpful to step back at look at [4] from a higher level: it's simply | ||
5333 | mapping from UTC to tz's standard time. | ||
5334 | |||
5335 | At this point, if | ||
5336 | |||
5337 | z.n - z.o = x.n [5] | ||
5338 | |||
5339 | we have an equivalent time, and are almost done. The insecurity here is | ||
5340 | at the start of daylight time. Picture US Eastern for concreteness. The wall | ||
5341 | time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don't make good | ||
5342 | sense then. The docs ask that an Eastern tzinfo class consider such a time to | ||
5343 | be EDT (because it's "after 2"), which is a redundant spelling of 1:MM EST | ||
5344 | on the day DST starts. We want to return the 1:MM EST spelling because that's | ||
5345 | the only spelling that makes sense on the local wall clock. | ||
5346 | |||
5347 | In fact, if [5] holds at this point, we do have the standard-time spelling, | ||
5348 | but that takes a bit of proof. We first prove a stronger result. What's the | ||
5349 | difference between the LHS and RHS of [5]? Let | ||
5350 | |||
5351 | diff = x.n - (z.n - z.o) [6] | ||
5352 | |||
5353 | Now | ||
5354 | z.n = by [4] | ||
5355 | (y + y.s).n = by #5 | ||
5356 | y.n + y.s = since y.n = x.n | ||
5357 | x.n + y.s = since z and y are have the same tzinfo member, | ||
5358 | y.s = z.s by #2 | ||
5359 | x.n + z.s | ||
5360 | |||
5361 | Plugging that back into [6] gives | ||
5362 | |||
5363 | diff = | ||
5364 | x.n - ((x.n + z.s) - z.o) = expanding | ||
5365 | x.n - x.n - z.s + z.o = cancelling | ||
5366 | - z.s + z.o = by #2 | ||
5367 | z.d | ||
5368 | |||
5369 | So diff = z.d. | ||
5370 | |||
5371 | If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time | ||
5372 | spelling we wanted in the endcase described above. We're done. Contrarily, | ||
5373 | if z.d = 0, then we have a UTC equivalent, and are also done. | ||
5374 | |||
5375 | If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to | ||
5376 | add to z (in effect, z is in tz's standard time, and we need to shift the | ||
5377 | local clock into tz's daylight time). | ||
5378 | |||
5379 | Let | ||
5380 | |||
5381 | z' = z + z.d = z + diff [7] | ||
5382 | |||
5383 | and we can again ask whether | ||
5384 | |||
5385 | z'.n - z'.o = x.n [8] | ||
5386 | |||
5387 | If so, we're done. If not, the tzinfo class is insane, according to the | ||
5388 | assumptions we've made. This also requires a bit of proof. As before, let's | ||
5389 | compute the difference between the LHS and RHS of [8] (and skipping some of | ||
5390 | the justifications for the kinds of substitutions we've done several times | ||
5391 | already): | ||
5392 | |||
5393 | diff' = x.n - (z'.n - z'.o) = replacing z'.n via [7] | ||
5394 | x.n - (z.n + diff - z'.o) = replacing diff via [6] | ||
5395 | x.n - (z.n + x.n - (z.n - z.o) - z'.o) = | ||
5396 | x.n - z.n - x.n + z.n - z.o + z'.o = cancel x.n | ||
5397 | - z.n + z.n - z.o + z'.o = cancel z.n | ||
5398 | - z.o + z'.o = #1 twice | ||
5399 | -z.s - z.d + z'.s + z'.d = z and z' have same tzinfo | ||
5400 | z'.d - z.d | ||
5401 | |||
5402 | So z' is UTC-equivalent to x iff z'.d = z.d at this point. If they are equal, | ||
5403 | we've found the UTC-equivalent so are done. In fact, we stop with [7] and | ||
5404 | return z', not bothering to compute z'.d. | ||
5405 | |||
5406 | How could z.d and z'd differ? z' = z + z.d [7], so merely moving z' by | ||
5407 | a dst() offset, and starting *from* a time already in DST (we know z.d != 0), | ||
5408 | would have to change the result dst() returns: we start in DST, and moving | ||
5409 | a little further into it takes us out of DST. | ||
5410 | |||
5411 | There isn't a sane case where this can happen. The closest it gets is at | ||
5412 | the end of DST, where there's an hour in UTC with no spelling in a hybrid | ||
5413 | tzinfo class. In US Eastern, that's 5:MM UTC = 0:MM EST = 1:MM EDT. During | ||
5414 | that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM | ||
5415 | UTC) because the docs insist on that, but 0:MM is taken as being in daylight | ||
5416 | time (4:MM UTC). There is no local time mapping to 5:MM UTC. The local | ||
5417 | clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in | ||
5418 | standard time. Since that's what the local clock *does*, we want to map both | ||
5419 | UTC hours 5:MM and 6:MM to 1:MM Eastern. The result is ambiguous | ||
5420 | in local time, but so it goes -- it's the way the local clock works. | ||
5421 | |||
5422 | When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0, | ||
5423 | so z=0:MM. z.d=60 (minutes) then, so [5] doesn't hold and we keep going. | ||
5424 | z' = z + z.d = 1:MM then, and z'.d=0, and z'.d - z.d = -60 != 0 so [8] | ||
5425 | (correctly) concludes that z' is not UTC-equivalent to x. | ||
5426 | |||
5427 | Because we know z.d said z was in daylight time (else [5] would have held and | ||
5428 | we would have stopped then), and we know z.d != z'.d (else [8] would have held | ||
5429 | and we would have stopped then), and there are only 2 possible values dst() can | ||
5430 | return in Eastern, it follows that z'.d must be 0 (which it is in the example, | ||
5431 | but the reasoning doesn't depend on the example -- it depends on there being | ||
5432 | two possible dst() outcomes, one zero and the other non-zero). Therefore | ||
5433 | z' must be in standard time, and is the spelling we want in this case. | ||
5434 | |||
5435 | Note again that z' is not UTC-equivalent as far as the hybrid tzinfo class is | ||
5436 | concerned (because it takes z' as being in standard time rather than the | ||
5437 | daylight time we intend here), but returning it gives the real-life "local | ||
5438 | clock repeats an hour" behavior when mapping the "unspellable" UTC hour into | ||
5439 | tz. | ||
5440 | |||
5441 | When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with | ||
5442 | the 1:MM standard time spelling we want. | ||
5443 | |||
5444 | So how can this break? One of the assumptions must be violated. Two | ||
5445 | possibilities: | ||
5446 | |||
5447 | 1) [2] effectively says that y.s is invariant across all y belong to a given | ||
5448 | time zone. This isn't true if, for political reasons or continental drift, | ||
5449 | a region decides to change its base offset from UTC. | ||
5450 | |||
5451 | 2) There may be versions of "double daylight" time where the tail end of | ||
5452 | the analysis gives up a step too early. I haven't thought about that | ||
5453 | enough to say. | ||
5454 | |||
5455 | In any case, it's clear that the default fromutc() is strong enough to handle | ||
5456 | "almost all" time zones: so long as the standard offset is invariant, it | ||
5457 | doesn't matter if daylight time transition points change from year to year, or | ||
5458 | if daylight time is skipped in some years; it doesn't matter how large or | ||
5459 | small dst() may get within its bounds; and it doesn't even matter if some | ||
5460 | perverse time zone returns a negative dst()). So a breaking case must be | ||
5461 | pretty bizarre, and a tzinfo subclass can override fromutc() if it is. | ||
5462 | --------------------------------------------------------------------------- */ |