Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

datetimemodule.c

Last change on this file was 391, checked in by dmik, 11 years ago
python: Merge vendor 2.7.6 to trunk.
Property svn:eol-style set to `native`
File size: 167.3 KB

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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/trunk/Modules/datetimemodule.c

Download in other formats: