File: | Modules/_datetimemodule.c |
Location: | line 1464, column 5 |
Description: | Value stored to 'x1' is never read |
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); |
Value stored to 'x1' is never read | |
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 | --------------------------------------------------------------------------- */ |