Mercurial > cpython-lru_cache-weakref

comparison Python/sysmodule.c @ 61467:f197407bdba2 3.1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Recorded merge of revisions 81032 via svnmerge from svn+ssh://pythondev@svn.python.org/python/branches/py3k ................ r81032 | antoine.pitrou | 2010-05-09 17:52:27 +0200 (dim., 09 mai 2010) | 9 lines Recorded merge of revisions 81029 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines Untabify C files. Will watch buildbots. ........ ................
author Antoine Pitrou <solipsis@pitrou.net>
date Sun, 09 May 2010 16:14:21 +0000
parents c6b4f4f2b9a8
children 9db8c414921f
comparison
equal deleted inserted replaced
61459:f8c19c5f5dd2 61467:f197407bdba2
43 #endif 43 #endif
44 44
45 PyObject * 45 PyObject *
46 PySys_GetObject(const char *name) 46 PySys_GetObject(const char *name)
47 { 47 {
48 PyThreadState *tstate = PyThreadState_GET(); 48 PyThreadState *tstate = PyThreadState_GET();
49 PyObject *sd = tstate->interp->sysdict; 49 PyObject *sd = tstate->interp->sysdict;
50 if (sd == NULL) 50 if (sd == NULL)
51 return NULL; 51 return NULL;
52 return PyDict_GetItemString(sd, name); 52 return PyDict_GetItemString(sd, name);
53 } 53 }
54 54
55 int 55 int
56 PySys_SetObject(const char *name, PyObject *v) 56 PySys_SetObject(const char *name, PyObject *v)
57 { 57 {
58 PyThreadState *tstate = PyThreadState_GET(); 58 PyThreadState *tstate = PyThreadState_GET();
59 PyObject *sd = tstate->interp->sysdict; 59 PyObject *sd = tstate->interp->sysdict;
60 if (v == NULL) { 60 if (v == NULL) {
61 if (PyDict_GetItemString(sd, name) == NULL) 61 if (PyDict_GetItemString(sd, name) == NULL)
62 return 0; 62 return 0;
63 else 63 else
64 return PyDict_DelItemString(sd, name); 64 return PyDict_DelItemString(sd, name);
65 } 65 }
66 else 66 else
67 return PyDict_SetItemString(sd, name, v); 67 return PyDict_SetItemString(sd, name, v);
68 } 68 }
69 69
70 static PyObject * 70 static PyObject *
71 sys_displayhook(PyObject *self, PyObject *o) 71 sys_displayhook(PyObject *self, PyObject *o)
72 { 72 {
73 PyObject *outf; 73 PyObject *outf;
74 PyInterpreterState *interp = PyThreadState_GET()->interp; 74 PyInterpreterState *interp = PyThreadState_GET()->interp;
75 PyObject *modules = interp->modules; 75 PyObject *modules = interp->modules;
76 PyObject *builtins = PyDict_GetItemString(modules, "builtins"); 76 PyObject *builtins = PyDict_GetItemString(modules, "builtins");
77 77
78 if (builtins == NULL) { 78 if (builtins == NULL) {
79 PyErr_SetString(PyExc_RuntimeError, "lost builtins module"); 79 PyErr_SetString(PyExc_RuntimeError, "lost builtins module");
80 return NULL; 80 return NULL;
81 } 81 }
82 82
83 /* Print value except if None */ 83 /* Print value except if None */
84 /* After printing, also assign to '_' */ 84 /* After printing, also assign to '_' */
85 /* Before, set '_' to None to avoid recursion */ 85 /* Before, set '_' to None to avoid recursion */
86 if (o == Py_None) { 86 if (o == Py_None) {
87 Py_INCREF(Py_None); 87 Py_INCREF(Py_None);
88 return Py_None; 88 return Py_None;
89 } 89 }
90 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0) 90 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
91 return NULL; 91 return NULL;
92 outf = PySys_GetObject("stdout"); 92 outf = PySys_GetObject("stdout");
93 if (outf == NULL || outf == Py_None) { 93 if (outf == NULL || outf == Py_None) {
94 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); 94 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
95 return NULL; 95 return NULL;
96 } 96 }
97 if (PyFile_WriteObject(o, outf, 0) != 0) 97 if (PyFile_WriteObject(o, outf, 0) != 0)
98 return NULL; 98 return NULL;
99 if (PyFile_WriteString("\n", outf) != 0) 99 if (PyFile_WriteString("\n", outf) != 0)
100 return NULL; 100 return NULL;
101 if (PyObject_SetAttrString(builtins, "_", o) != 0) 101 if (PyObject_SetAttrString(builtins, "_", o) != 0)
102 return NULL; 102 return NULL;
103 Py_INCREF(Py_None); 103 Py_INCREF(Py_None);
104 return Py_None; 104 return Py_None;
105 } 105 }
106 106
107 PyDoc_STRVAR(displayhook_doc, 107 PyDoc_STRVAR(displayhook_doc,
108 "displayhook(object) -> None\n" 108 "displayhook(object) -> None\n"
109 "\n" 109 "\n"
111 ); 111 );
112 112
113 static PyObject * 113 static PyObject *
114 sys_excepthook(PyObject* self, PyObject* args) 114 sys_excepthook(PyObject* self, PyObject* args)
115 { 115 {
116 PyObject *exc, *value, *tb; 116 PyObject *exc, *value, *tb;
117 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb)) 117 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
118 return NULL; 118 return NULL;
119 PyErr_Display(exc, value, tb); 119 PyErr_Display(exc, value, tb);
120 Py_INCREF(Py_None); 120 Py_INCREF(Py_None);
121 return Py_None; 121 return Py_None;
122 } 122 }
123 123
124 PyDoc_STRVAR(excepthook_doc, 124 PyDoc_STRVAR(excepthook_doc,
125 "excepthook(exctype, value, traceback) -> None\n" 125 "excepthook(exctype, value, traceback) -> None\n"
126 "\n" 126 "\n"
128 ); 128 );
129 129
130 static PyObject * 130 static PyObject *
131 sys_exc_info(PyObject *self, PyObject *noargs) 131 sys_exc_info(PyObject *self, PyObject *noargs)
132 { 132 {
133 PyThreadState *tstate; 133 PyThreadState *tstate;
134 tstate = PyThreadState_GET(); 134 tstate = PyThreadState_GET();
135 return Py_BuildValue( 135 return Py_BuildValue(
136 "(OOO)", 136 "(OOO)",
137 tstate->exc_type != NULL ? tstate->exc_type : Py_None, 137 tstate->exc_type != NULL ? tstate->exc_type : Py_None,
138 tstate->exc_value != NULL ? tstate->exc_value : Py_None, 138 tstate->exc_value != NULL ? tstate->exc_value : Py_None,
139 tstate->exc_traceback != NULL ? 139 tstate->exc_traceback != NULL ?
140 tstate->exc_traceback : Py_None); 140 tstate->exc_traceback : Py_None);
141 } 141 }
142 142
143 PyDoc_STRVAR(exc_info_doc, 143 PyDoc_STRVAR(exc_info_doc,
144 "exc_info() -> (type, value, traceback)\n\ 144 "exc_info() -> (type, value, traceback)\n\
145 \n\ 145 \n\
148 ); 148 );
149 149
150 static PyObject * 150 static PyObject *
151 sys_exit(PyObject *self, PyObject *args) 151 sys_exit(PyObject *self, PyObject *args)
152 { 152 {
153 PyObject *exit_code = 0; 153 PyObject *exit_code = 0;
154 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code)) 154 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
155 return NULL; 155 return NULL;
156 /* Raise SystemExit so callers may catch it or clean up. */ 156 /* Raise SystemExit so callers may catch it or clean up. */
157 PyErr_SetObject(PyExc_SystemExit, exit_code); 157 PyErr_SetObject(PyExc_SystemExit, exit_code);
158 return NULL; 158 return NULL;
159 } 159 }
160 160
161 PyDoc_STRVAR(exit_doc, 161 PyDoc_STRVAR(exit_doc,
162 "exit([status])\n\ 162 "exit([status])\n\
163 \n\ 163 \n\
170 170
171 171
172 static PyObject * 172 static PyObject *
173 sys_getdefaultencoding(PyObject *self) 173 sys_getdefaultencoding(PyObject *self)
174 { 174 {
175 return PyUnicode_FromString(PyUnicode_GetDefaultEncoding()); 175 return PyUnicode_FromString(PyUnicode_GetDefaultEncoding());
176 } 176 }
177 177
178 PyDoc_STRVAR(getdefaultencoding_doc, 178 PyDoc_STRVAR(getdefaultencoding_doc,
179 "getdefaultencoding() -> string\n\ 179 "getdefaultencoding() -> string\n\
180 \n\ 180 \n\
183 ); 183 );
184 184
185 static PyObject * 185 static PyObject *
186 sys_setdefaultencoding(PyObject *self, PyObject *args) 186 sys_setdefaultencoding(PyObject *self, PyObject *args)
187 { 187 {
188 char *encoding; 188 char *encoding;
189 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding)) 189 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
190 return NULL; 190 return NULL;
191 if (PyUnicode_SetDefaultEncoding(encoding)) 191 if (PyUnicode_SetDefaultEncoding(encoding))
192 return NULL; 192 return NULL;
193 Py_INCREF(Py_None); 193 Py_INCREF(Py_None);
194 return Py_None; 194 return Py_None;
195 } 195 }
196 196
197 PyDoc_STRVAR(setdefaultencoding_doc, 197 PyDoc_STRVAR(setdefaultencoding_doc,
198 "setdefaultencoding(encoding)\n\ 198 "setdefaultencoding(encoding)\n\
199 \n\ 199 \n\
201 ); 201 );
202 202
203 static PyObject * 203 static PyObject *
204 sys_getfilesystemencoding(PyObject *self) 204 sys_getfilesystemencoding(PyObject *self)
205 { 205 {
206 if (Py_FileSystemDefaultEncoding) 206 if (Py_FileSystemDefaultEncoding)
207 return PyUnicode_FromString(Py_FileSystemDefaultEncoding); 207 return PyUnicode_FromString(Py_FileSystemDefaultEncoding);
208 Py_INCREF(Py_None); 208 Py_INCREF(Py_None);
209 return Py_None; 209 return Py_None;
210 } 210 }
211 211
212 PyDoc_STRVAR(getfilesystemencoding_doc, 212 PyDoc_STRVAR(getfilesystemencoding_doc,
213 "getfilesystemencoding() -> string\n\ 213 "getfilesystemencoding() -> string\n\
214 \n\ 214 \n\
217 ); 217 );
218 218
219 static PyObject * 219 static PyObject *
220 sys_setfilesystemencoding(PyObject *self, PyObject *args) 220 sys_setfilesystemencoding(PyObject *self, PyObject *args)
221 { 221 {
222 PyObject *new_encoding; 222 PyObject *new_encoding;
223 if (!PyArg_ParseTuple(args, "U:setfilesystemencoding", &new_encoding)) 223 if (!PyArg_ParseTuple(args, "U:setfilesystemencoding", &new_encoding))
224 return NULL; 224 return NULL;
225 if (_Py_SetFileSystemEncoding(new_encoding)) 225 if (_Py_SetFileSystemEncoding(new_encoding))
226 return NULL; 226 return NULL;
227 Py_INCREF(Py_None); 227 Py_INCREF(Py_None);
228 return Py_None; 228 return Py_None;
229 } 229 }
230 230
231 PyDoc_STRVAR(setfilesystemencoding_doc, 231 PyDoc_STRVAR(setfilesystemencoding_doc,
232 "setfilesystemencoding(string) -> None\n\ 232 "setfilesystemencoding(string) -> None\n\
233 \n\ 233 \n\
236 ); 236 );
237 237
238 static PyObject * 238 static PyObject *
239 sys_intern(PyObject *self, PyObject *args) 239 sys_intern(PyObject *self, PyObject *args)
240 { 240 {
241 PyObject *s; 241 PyObject *s;
242 if (!PyArg_ParseTuple(args, "U:intern", &s)) 242 if (!PyArg_ParseTuple(args, "U:intern", &s))
243 return NULL; 243 return NULL;
244 if (PyUnicode_CheckExact(s)) { 244 if (PyUnicode_CheckExact(s)) {
245 Py_INCREF(s); 245 Py_INCREF(s);
246 PyUnicode_InternInPlace(&s); 246 PyUnicode_InternInPlace(&s);
247 return s; 247 return s;
248 } 248 }
249 else { 249 else {
250 PyErr_Format(PyExc_TypeError, 250 PyErr_Format(PyExc_TypeError,
251 "can't intern %.400s", s->ob_type->tp_name); 251 "can't intern %.400s", s->ob_type->tp_name);
252 return NULL; 252 return NULL;
253 } 253 }
254 } 254 }
255 255
256 PyDoc_STRVAR(intern_doc, 256 PyDoc_STRVAR(intern_doc,
257 "intern(string) -> string\n\ 257 "intern(string) -> string\n\
258 \n\ 258 \n\
269 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL}; 269 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
270 270
271 static int 271 static int
272 trace_init(void) 272 trace_init(void)
273 { 273 {
274 static char *whatnames[7] = {"call", "exception", "line", "return", 274 static char *whatnames[7] = {"call", "exception", "line", "return",
275 "c_call", "c_exception", "c_return"}; 275 "c_call", "c_exception", "c_return"};
276 PyObject *name; 276 PyObject *name;
277 int i; 277 int i;
278 for (i = 0; i < 7; ++i) { 278 for (i = 0; i < 7; ++i) {
279 if (whatstrings[i] == NULL) { 279 if (whatstrings[i] == NULL) {
280 name = PyUnicode_InternFromString(whatnames[i]); 280 name = PyUnicode_InternFromString(whatnames[i]);
281 if (name == NULL) 281 if (name == NULL)
282 return -1; 282 return -1;
283 whatstrings[i] = name; 283 whatstrings[i] = name;
284 } 284 }
285 } 285 }
286 return 0; 286 return 0;
287 } 287 }
288 288
289 289
290 static PyObject * 290 static PyObject *
291 call_trampoline(PyThreadState *tstate, PyObject* callback, 291 call_trampoline(PyThreadState *tstate, PyObject* callback,
292 PyFrameObject *frame, int what, PyObject *arg) 292 PyFrameObject *frame, int what, PyObject *arg)
293 { 293 {
294 PyObject *args = PyTuple_New(3); 294 PyObject *args = PyTuple_New(3);
295 PyObject *whatstr; 295 PyObject *whatstr;
296 PyObject *result; 296 PyObject *result;
297 297
298 if (args == NULL) 298 if (args == NULL)
299 return NULL; 299 return NULL;
300 Py_INCREF(frame); 300 Py_INCREF(frame);
301 whatstr = whatstrings[what]; 301 whatstr = whatstrings[what];
302 Py_INCREF(whatstr); 302 Py_INCREF(whatstr);
303 if (arg == NULL) 303 if (arg == NULL)
304 arg = Py_None; 304 arg = Py_None;
305 Py_INCREF(arg); 305 Py_INCREF(arg);
306 PyTuple_SET_ITEM(args, 0, (PyObject *)frame); 306 PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
307 PyTuple_SET_ITEM(args, 1, whatstr); 307 PyTuple_SET_ITEM(args, 1, whatstr);
308 PyTuple_SET_ITEM(args, 2, arg); 308 PyTuple_SET_ITEM(args, 2, arg);
309 309
310 /* call the Python-level function */ 310 /* call the Python-level function */
311 PyFrame_FastToLocals(frame); 311 PyFrame_FastToLocals(frame);
312 result = PyEval_CallObject(callback, args); 312 result = PyEval_CallObject(callback, args);
313 PyFrame_LocalsToFast(frame, 1); 313 PyFrame_LocalsToFast(frame, 1);
314 if (result == NULL) 314 if (result == NULL)
315 PyTraceBack_Here(frame); 315 PyTraceBack_Here(frame);
316 316
317 /* cleanup */ 317 /* cleanup */
318 Py_DECREF(args); 318 Py_DECREF(args);
319 return result; 319 return result;
320 } 320 }
321 321
322 static int 322 static int
323 profile_trampoline(PyObject *self, PyFrameObject *frame, 323 profile_trampoline(PyObject *self, PyFrameObject *frame,
324 int what, PyObject *arg) 324 int what, PyObject *arg)
325 { 325 {
326 PyThreadState *tstate = frame->f_tstate; 326 PyThreadState *tstate = frame->f_tstate;
327 PyObject *result; 327 PyObject *result;
328 328
329 if (arg == NULL) 329 if (arg == NULL)
330 arg = Py_None; 330 arg = Py_None;
331 result = call_trampoline(tstate, self, frame, what, arg); 331 result = call_trampoline(tstate, self, frame, what, arg);
332 if (result == NULL) { 332 if (result == NULL) {
333 PyEval_SetProfile(NULL, NULL); 333 PyEval_SetProfile(NULL, NULL);
334 return -1; 334 return -1;
335 } 335 }
336 Py_DECREF(result); 336 Py_DECREF(result);
337 return 0; 337 return 0;
338 } 338 }
339 339
340 static int 340 static int
341 trace_trampoline(PyObject *self, PyFrameObject *frame, 341 trace_trampoline(PyObject *self, PyFrameObject *frame,
342 int what, PyObject *arg) 342 int what, PyObject *arg)
343 { 343 {
344 PyThreadState *tstate = frame->f_tstate; 344 PyThreadState *tstate = frame->f_tstate;
345 PyObject *callback; 345 PyObject *callback;
346 PyObject *result; 346 PyObject *result;
347 347
348 if (what == PyTrace_CALL) 348 if (what == PyTrace_CALL)
349 callback = self; 349 callback = self;
350 else 350 else
351 callback = frame->f_trace; 351 callback = frame->f_trace;
352 if (callback == NULL) 352 if (callback == NULL)
353 return 0; 353 return 0;
354 result = call_trampoline(tstate, callback, frame, what, arg); 354 result = call_trampoline(tstate, callback, frame, what, arg);
355 if (result == NULL) { 355 if (result == NULL) {
356 PyEval_SetTrace(NULL, NULL); 356 PyEval_SetTrace(NULL, NULL);
357 Py_XDECREF(frame->f_trace); 357 Py_XDECREF(frame->f_trace);
358 frame->f_trace = NULL; 358 frame->f_trace = NULL;
359 return -1; 359 return -1;
360 } 360 }
361 if (result != Py_None) { 361 if (result != Py_None) {
362 PyObject *temp = frame->f_trace; 362 PyObject *temp = frame->f_trace;
363 frame->f_trace = NULL; 363 frame->f_trace = NULL;
364 Py_XDECREF(temp); 364 Py_XDECREF(temp);
365 frame->f_trace = result; 365 frame->f_trace = result;
366 } 366 }
367 else { 367 else {
368 Py_DECREF(result); 368 Py_DECREF(result);
369 } 369 }
370 return 0; 370 return 0;
371 } 371 }
372 372
373 static PyObject * 373 static PyObject *
374 sys_settrace(PyObject *self, PyObject *args) 374 sys_settrace(PyObject *self, PyObject *args)
375 { 375 {
376 if (trace_init() == -1) 376 if (trace_init() == -1)
377 return NULL; 377 return NULL;
378 if (args == Py_None) 378 if (args == Py_None)
379 PyEval_SetTrace(NULL, NULL); 379 PyEval_SetTrace(NULL, NULL);
380 else 380 else
381 PyEval_SetTrace(trace_trampoline, args); 381 PyEval_SetTrace(trace_trampoline, args);
382 Py_INCREF(Py_None); 382 Py_INCREF(Py_None);
383 return Py_None; 383 return Py_None;
384 } 384 }
385 385
386 PyDoc_STRVAR(settrace_doc, 386 PyDoc_STRVAR(settrace_doc,
387 "settrace(function)\n\ 387 "settrace(function)\n\
388 \n\ 388 \n\
391 ); 391 );
392 392
393 static PyObject * 393 static PyObject *
394 sys_gettrace(PyObject *self, PyObject *args) 394 sys_gettrace(PyObject *self, PyObject *args)
395 { 395 {
396 PyThreadState *tstate = PyThreadState_GET(); 396 PyThreadState *tstate = PyThreadState_GET();
397 PyObject *temp = tstate->c_traceobj; 397 PyObject *temp = tstate->c_traceobj;
398 398
399 if (temp == NULL) 399 if (temp == NULL)
400 temp = Py_None; 400 temp = Py_None;
401 Py_INCREF(temp); 401 Py_INCREF(temp);
402 return temp; 402 return temp;
403 } 403 }
404 404
405 PyDoc_STRVAR(gettrace_doc, 405 PyDoc_STRVAR(gettrace_doc,
406 "gettrace()\n\ 406 "gettrace()\n\
407 \n\ 407 \n\
410 ); 410 );
411 411
412 static PyObject * 412 static PyObject *
413 sys_setprofile(PyObject *self, PyObject *args) 413 sys_setprofile(PyObject *self, PyObject *args)
414 { 414 {
415 if (trace_init() == -1) 415 if (trace_init() == -1)
416 return NULL; 416 return NULL;
417 if (args == Py_None) 417 if (args == Py_None)
418 PyEval_SetProfile(NULL, NULL); 418 PyEval_SetProfile(NULL, NULL);
419 else 419 else
420 PyEval_SetProfile(profile_trampoline, args); 420 PyEval_SetProfile(profile_trampoline, args);
421 Py_INCREF(Py_None); 421 Py_INCREF(Py_None);
422 return Py_None; 422 return Py_None;
423 } 423 }
424 424
425 PyDoc_STRVAR(setprofile_doc, 425 PyDoc_STRVAR(setprofile_doc,
426 "setprofile(function)\n\ 426 "setprofile(function)\n\
427 \n\ 427 \n\
430 ); 430 );
431 431
432 static PyObject * 432 static PyObject *
433 sys_getprofile(PyObject *self, PyObject *args) 433 sys_getprofile(PyObject *self, PyObject *args)
434 { 434 {
435 PyThreadState *tstate = PyThreadState_GET(); 435 PyThreadState *tstate = PyThreadState_GET();
436 PyObject *temp = tstate->c_profileobj; 436 PyObject *temp = tstate->c_profileobj;
437 437
438 if (temp == NULL) 438 if (temp == NULL)
439 temp = Py_None; 439 temp = Py_None;
440 Py_INCREF(temp); 440 Py_INCREF(temp);
441 return temp; 441 return temp;
442 } 442 }
443 443
444 PyDoc_STRVAR(getprofile_doc, 444 PyDoc_STRVAR(getprofile_doc,
445 "getprofile()\n\ 445 "getprofile()\n\
446 \n\ 446 \n\
449 ); 449 );
450 450
451 static PyObject * 451 static PyObject *
452 sys_setcheckinterval(PyObject *self, PyObject *args) 452 sys_setcheckinterval(PyObject *self, PyObject *args)
453 { 453 {
454 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval)) 454 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
455 return NULL; 455 return NULL;
456 Py_INCREF(Py_None); 456 Py_INCREF(Py_None);
457 return Py_None; 457 return Py_None;
458 } 458 }
459 459
460 PyDoc_STRVAR(setcheckinterval_doc, 460 PyDoc_STRVAR(setcheckinterval_doc,
461 "setcheckinterval(n)\n\ 461 "setcheckinterval(n)\n\
462 \n\ 462 \n\
465 ); 465 );
466 466
467 static PyObject * 467 static PyObject *
468 sys_getcheckinterval(PyObject *self, PyObject *args) 468 sys_getcheckinterval(PyObject *self, PyObject *args)
469 { 469 {
470 return PyLong_FromLong(_Py_CheckInterval); 470 return PyLong_FromLong(_Py_CheckInterval);
471 } 471 }
472 472
473 PyDoc_STRVAR(getcheckinterval_doc, 473 PyDoc_STRVAR(getcheckinterval_doc,
474 "getcheckinterval() -> current check interval; see setcheckinterval()." 474 "getcheckinterval() -> current check interval; see setcheckinterval()."
475 ); 475 );
476 476
477 #ifdef WITH_TSC 477 #ifdef WITH_TSC
478 static PyObject * 478 static PyObject *
479 sys_settscdump(PyObject *self, PyObject *args) 479 sys_settscdump(PyObject *self, PyObject *args)
480 { 480 {
481 int bool; 481 int bool;
482 PyThreadState *tstate = PyThreadState_Get(); 482 PyThreadState *tstate = PyThreadState_Get();
483 483
484 if (!PyArg_ParseTuple(args, "i:settscdump", &bool)) 484 if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
485 return NULL; 485 return NULL;
486 if (bool) 486 if (bool)
487 tstate->interp->tscdump = 1; 487 tstate->interp->tscdump = 1;
488 else 488 else
489 tstate->interp->tscdump = 0; 489 tstate->interp->tscdump = 0;
490 Py_INCREF(Py_None); 490 Py_INCREF(Py_None);
491 return Py_None; 491 return Py_None;
492 492
493 } 493 }
494 494
495 PyDoc_STRVAR(settscdump_doc, 495 PyDoc_STRVAR(settscdump_doc,
496 "settscdump(bool)\n\ 496 "settscdump(bool)\n\
502 #endif /* TSC */ 502 #endif /* TSC */
503 503
504 static PyObject * 504 static PyObject *
505 sys_setrecursionlimit(PyObject *self, PyObject *args) 505 sys_setrecursionlimit(PyObject *self, PyObject *args)
506 { 506 {
507 int new_limit; 507 int new_limit;
508 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) 508 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
509 return NULL; 509 return NULL;
510 if (new_limit <= 0) { 510 if (new_limit <= 0) {
511 PyErr_SetString(PyExc_ValueError, 511 PyErr_SetString(PyExc_ValueError,
512 "recursion limit must be positive"); 512 "recursion limit must be positive");
513 return NULL; 513 return NULL;
514 } 514 }
515 Py_SetRecursionLimit(new_limit); 515 Py_SetRecursionLimit(new_limit);
516 Py_INCREF(Py_None); 516 Py_INCREF(Py_None);
517 return Py_None; 517 return Py_None;
518 } 518 }
519 519
520 PyDoc_STRVAR(setrecursionlimit_doc, 520 PyDoc_STRVAR(setrecursionlimit_doc,
521 "setrecursionlimit(n)\n\ 521 "setrecursionlimit(n)\n\
522 \n\ 522 \n\
527 ); 527 );
528 528
529 static PyObject * 529 static PyObject *
530 sys_getrecursionlimit(PyObject *self) 530 sys_getrecursionlimit(PyObject *self)
531 { 531 {
532 return PyLong_FromLong(Py_GetRecursionLimit()); 532 return PyLong_FromLong(Py_GetRecursionLimit());
533 } 533 }
534 534
535 PyDoc_STRVAR(getrecursionlimit_doc, 535 PyDoc_STRVAR(getrecursionlimit_doc,
536 "getrecursionlimit()\n\ 536 "getrecursionlimit()\n\
537 \n\ 537 \n\
552 ); 552 );
553 553
554 static PyObject * 554 static PyObject *
555 sys_getwindowsversion(PyObject *self) 555 sys_getwindowsversion(PyObject *self)
556 { 556 {
557 OSVERSIONINFO ver; 557 OSVERSIONINFO ver;
558 ver.dwOSVersionInfoSize = sizeof(ver); 558 ver.dwOSVersionInfoSize = sizeof(ver);
559 if (!GetVersionEx(&ver)) 559 if (!GetVersionEx(&ver))
560 return PyErr_SetFromWindowsErr(0); 560 return PyErr_SetFromWindowsErr(0);
561 return Py_BuildValue("HHHHs", 561 return Py_BuildValue("HHHHs",
562 ver.dwMajorVersion, 562 ver.dwMajorVersion,
563 ver.dwMinorVersion, 563 ver.dwMinorVersion,
564 ver.dwBuildNumber, 564 ver.dwBuildNumber,
565 ver.dwPlatformId, 565 ver.dwPlatformId,
566 ver.szCSDVersion); 566 ver.szCSDVersion);
567 } 567 }
568 568
569 #endif /* MS_WINDOWS */ 569 #endif /* MS_WINDOWS */
570 570
571 #ifdef HAVE_DLOPEN 571 #ifdef HAVE_DLOPEN
572 static PyObject * 572 static PyObject *
573 sys_setdlopenflags(PyObject *self, PyObject *args) 573 sys_setdlopenflags(PyObject *self, PyObject *args)
574 { 574 {
575 int new_val; 575 int new_val;
576 PyThreadState *tstate = PyThreadState_GET(); 576 PyThreadState *tstate = PyThreadState_GET();
577 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val)) 577 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
578 return NULL; 578 return NULL;
579 if (!tstate) 579 if (!tstate)
580 return NULL; 580 return NULL;
581 tstate->interp->dlopenflags = new_val; 581 tstate->interp->dlopenflags = new_val;
582 Py_INCREF(Py_None); 582 Py_INCREF(Py_None);
583 return Py_None; 583 return Py_None;
584 } 584 }
585 585
586 PyDoc_STRVAR(setdlopenflags_doc, 586 PyDoc_STRVAR(setdlopenflags_doc,
587 "setdlopenflags(n) -> None\n\ 587 "setdlopenflags(n) -> None\n\
588 \n\ 588 \n\
596 h2py script."); 596 h2py script.");
597 597
598 static PyObject * 598 static PyObject *
599 sys_getdlopenflags(PyObject *self, PyObject *args) 599 sys_getdlopenflags(PyObject *self, PyObject *args)
600 { 600 {
601 PyThreadState *tstate = PyThreadState_GET(); 601 PyThreadState *tstate = PyThreadState_GET();
602 if (!tstate) 602 if (!tstate)
603 return NULL; 603 return NULL;
604 return PyLong_FromLong(tstate->interp->dlopenflags); 604 return PyLong_FromLong(tstate->interp->dlopenflags);
605 } 605 }
606 606
607 PyDoc_STRVAR(getdlopenflags_doc, 607 PyDoc_STRVAR(getdlopenflags_doc,
608 "getdlopenflags() -> int\n\ 608 "getdlopenflags() -> int\n\
609 \n\ 609 \n\
610 Return the current value of the flags that are used for dlopen calls.\n\ 610 Return the current value of the flags that are used for dlopen calls.\n\
611 The flag constants are defined in the ctypes and DLFCN modules."); 611 The flag constants are defined in the ctypes and DLFCN modules.");
612 612
613 #endif /* HAVE_DLOPEN */ 613 #endif /* HAVE_DLOPEN */
614 614
615 #ifdef USE_MALLOPT 615 #ifdef USE_MALLOPT
616 /* Link with -lmalloc (or -lmpc) on an SGI */ 616 /* Link with -lmalloc (or -lmpc) on an SGI */
617 #include <malloc.h> 617 #include <malloc.h>
618 618
619 static PyObject * 619 static PyObject *
620 sys_mdebug(PyObject *self, PyObject *args) 620 sys_mdebug(PyObject *self, PyObject *args)
621 { 621 {
622 int flag; 622 int flag;
623 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 623 if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
624 return NULL; 624 return NULL;
625 mallopt(M_DEBUG, flag); 625 mallopt(M_DEBUG, flag);
626 Py_INCREF(Py_None); 626 Py_INCREF(Py_None);
627 return Py_None; 627 return Py_None;
628 } 628 }
629 #endif /* USE_MALLOPT */ 629 #endif /* USE_MALLOPT */
630 630
631 static PyObject * 631 static PyObject *
632 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds) 632 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
633 { 633 {
634 PyObject *res = NULL; 634 PyObject *res = NULL;
635 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL; 635 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL;
636 static char *kwlist[] = {"object", "default", 0}; 636 static char *kwlist[] = {"object", "default", 0};
637 PyObject *o, *dflt = NULL; 637 PyObject *o, *dflt = NULL;
638 PyObject *method; 638 PyObject *method;
639 639
640 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", 640 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
641 kwlist, &o, &dflt)) 641 kwlist, &o, &dflt))
642 return NULL; 642 return NULL;
643 643
644 /* Initialize static variable for GC head size */ 644 /* Initialize static variable for GC head size */
645 if (gc_head_size == NULL) { 645 if (gc_head_size == NULL) {
646 gc_head_size = PyLong_FromSsize_t(sizeof(PyGC_Head)); 646 gc_head_size = PyLong_FromSsize_t(sizeof(PyGC_Head));
647 if (gc_head_size == NULL) 647 if (gc_head_size == NULL)
648 return NULL; 648 return NULL;
649 } 649 }
650 650
651 /* Make sure the type is initialized. float gets initialized late */ 651 /* Make sure the type is initialized. float gets initialized late */
652 if (PyType_Ready(Py_TYPE(o)) < 0) 652 if (PyType_Ready(Py_TYPE(o)) < 0)
653 return NULL; 653 return NULL;
654 654
655 method = _PyObject_LookupSpecial(o, "__sizeof__", 655 method = _PyObject_LookupSpecial(o, "__sizeof__",
656 &str__sizeof__); 656 &str__sizeof__);
657 if (method == NULL) { 657 if (method == NULL) {
658 if (!PyErr_Occurred()) 658 if (!PyErr_Occurred())
659 PyErr_Format(PyExc_TypeError, 659 PyErr_Format(PyExc_TypeError,
660 "Type %.100s doesn't define __sizeof__", 660 "Type %.100s doesn't define __sizeof__",
661 Py_TYPE(o)->tp_name); 661 Py_TYPE(o)->tp_name);
662 } 662 }
663 else { 663 else {
664 res = PyObject_CallFunctionObjArgs(method, NULL); 664 res = PyObject_CallFunctionObjArgs(method, NULL);
665 Py_DECREF(method); 665 Py_DECREF(method);
666 } 666 }
667 667
668 /* Has a default value been given */ 668 /* Has a default value been given */
669 if ((res == NULL) && (dflt != NULL) && 669 if ((res == NULL) && (dflt != NULL) &&
670 PyErr_ExceptionMatches(PyExc_TypeError)) 670 PyErr_ExceptionMatches(PyExc_TypeError))
671 { 671 {
672 PyErr_Clear(); 672 PyErr_Clear();
673 Py_INCREF(dflt); 673 Py_INCREF(dflt);
674 return dflt; 674 return dflt;
675 } 675 }
676 else if (res == NULL) 676 else if (res == NULL)
677 return res; 677 return res;
678 678
679 /* add gc_head size */ 679 /* add gc_head size */
680 if (PyObject_IS_GC(o)) { 680 if (PyObject_IS_GC(o)) {
681 PyObject *tmp = res; 681 PyObject *tmp = res;
682 res = PyNumber_Add(tmp, gc_head_size); 682 res = PyNumber_Add(tmp, gc_head_size);
683 Py_DECREF(tmp); 683 Py_DECREF(tmp);
684 } 684 }
685 return res; 685 return res;
686 } 686 }
687 687
688 PyDoc_STRVAR(getsizeof_doc, 688 PyDoc_STRVAR(getsizeof_doc,
689 "getsizeof(object, default) -> int\n\ 689 "getsizeof(object, default) -> int\n\
690 \n\ 690 \n\
691 Return the size of object in bytes."); 691 Return the size of object in bytes.");
692 692
693 static PyObject * 693 static PyObject *
694 sys_getrefcount(PyObject *self, PyObject *arg) 694 sys_getrefcount(PyObject *self, PyObject *arg)
695 { 695 {
696 return PyLong_FromSsize_t(arg->ob_refcnt); 696 return PyLong_FromSsize_t(arg->ob_refcnt);
697 } 697 }
698 698
699 #ifdef Py_REF_DEBUG 699 #ifdef Py_REF_DEBUG
700 static PyObject * 700 static PyObject *
701 sys_gettotalrefcount(PyObject *self) 701 sys_gettotalrefcount(PyObject *self)
702 { 702 {
703 return PyLong_FromSsize_t(_Py_GetRefTotal()); 703 return PyLong_FromSsize_t(_Py_GetRefTotal());
704 } 704 }
705 #endif /* Py_REF_DEBUG */ 705 #endif /* Py_REF_DEBUG */
706 706
707 PyDoc_STRVAR(getrefcount_doc, 707 PyDoc_STRVAR(getrefcount_doc,
708 "getrefcount(object) -> integer\n\ 708 "getrefcount(object) -> integer\n\
714 714
715 #ifdef COUNT_ALLOCS 715 #ifdef COUNT_ALLOCS
716 static PyObject * 716 static PyObject *
717 sys_getcounts(PyObject *self) 717 sys_getcounts(PyObject *self)
718 { 718 {
719 extern PyObject *get_counts(void); 719 extern PyObject *get_counts(void);
720 720
721 return get_counts(); 721 return get_counts();
722 } 722 }
723 #endif 723 #endif
724 724
725 PyDoc_STRVAR(getframe_doc, 725 PyDoc_STRVAR(getframe_doc,
726 "_getframe([depth]) -> frameobject\n\ 726 "_getframe([depth]) -> frameobject\n\
735 ); 735 );
736 736
737 static PyObject * 737 static PyObject *
738 sys_getframe(PyObject *self, PyObject *args) 738 sys_getframe(PyObject *self, PyObject *args)
739 { 739 {
740 PyFrameObject *f = PyThreadState_GET()->frame; 740 PyFrameObject *f = PyThreadState_GET()->frame;
741 int depth = -1; 741 int depth = -1;
742 742
743 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 743 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
744 return NULL; 744 return NULL;
745 745
746 while (depth > 0 && f != NULL) { 746 while (depth > 0 && f != NULL) {
747 f = f->f_back; 747 f = f->f_back;
748 --depth; 748 --depth;
749 } 749 }
750 if (f == NULL) { 750 if (f == NULL) {
751 PyErr_SetString(PyExc_ValueError, 751 PyErr_SetString(PyExc_ValueError,
752 "call stack is not deep enough"); 752 "call stack is not deep enough");
753 return NULL; 753 return NULL;
754 } 754 }
755 Py_INCREF(f); 755 Py_INCREF(f);
756 return (PyObject*)f; 756 return (PyObject*)f;
757 } 757 }
758 758
759 PyDoc_STRVAR(current_frames_doc, 759 PyDoc_STRVAR(current_frames_doc,
760 "_current_frames() -> dictionary\n\ 760 "_current_frames() -> dictionary\n\
761 \n\ 761 \n\
766 ); 766 );
767 767
768 static PyObject * 768 static PyObject *
769 sys_current_frames(PyObject *self, PyObject *noargs) 769 sys_current_frames(PyObject *self, PyObject *noargs)
770 { 770 {
771 return _PyThread_CurrentFrames(); 771 return _PyThread_CurrentFrames();
772 } 772 }
773 773
774 PyDoc_STRVAR(call_tracing_doc, 774 PyDoc_STRVAR(call_tracing_doc,
775 "call_tracing(func, args) -> object\n\ 775 "call_tracing(func, args) -> object\n\
776 \n\ 776 \n\
780 ); 780 );
781 781
782 static PyObject * 782 static PyObject *
783 sys_call_tracing(PyObject *self, PyObject *args) 783 sys_call_tracing(PyObject *self, PyObject *args)
784 { 784 {
785 PyObject *func, *funcargs; 785 PyObject *func, *funcargs;
786 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs)) 786 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
787 return NULL; 787 return NULL;
788 return _PyEval_CallTracing(func, funcargs); 788 return _PyEval_CallTracing(func, funcargs);
789 } 789 }
790 790
791 PyDoc_STRVAR(callstats_doc, 791 PyDoc_STRVAR(callstats_doc,
792 "callstats() -> tuple of integers\n\ 792 "callstats() -> tuple of integers\n\
793 \n\ 793 \n\
830 #endif 830 #endif
831 831
832 static PyObject * 832 static PyObject *
833 sys_clear_type_cache(PyObject* self, PyObject* args) 833 sys_clear_type_cache(PyObject* self, PyObject* args)
834 { 834 {
835 PyType_ClearCache(); 835 PyType_ClearCache();
836 Py_RETURN_NONE; 836 Py_RETURN_NONE;
837 } 837 }
838 838
839 PyDoc_STRVAR(sys_clear_type_cache__doc__, 839 PyDoc_STRVAR(sys_clear_type_cache__doc__,
840 "_clear_type_cache() -> None\n\ 840 "_clear_type_cache() -> None\n\
841 Clear the internal type lookup cache."); 841 Clear the internal type lookup cache.");
842 842
843 843
844 static PyMethodDef sys_methods[] = { 844 static PyMethodDef sys_methods[] = {
845 /* Might as well keep this in alphabetic order */ 845 /* Might as well keep this in alphabetic order */
846 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS, 846 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
847 callstats_doc}, 847 callstats_doc},
848 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS, 848 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
849 sys_clear_type_cache__doc__}, 849 sys_clear_type_cache__doc__},
850 {"_current_frames", sys_current_frames, METH_NOARGS, 850 {"_current_frames", sys_current_frames, METH_NOARGS,
851 current_frames_doc}, 851 current_frames_doc},
852 {"displayhook", sys_displayhook, METH_O, displayhook_doc}, 852 {"displayhook", sys_displayhook, METH_O, displayhook_doc},
853 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc}, 853 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
854 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, 854 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
855 {"exit", sys_exit, METH_VARARGS, exit_doc}, 855 {"exit", sys_exit, METH_VARARGS, exit_doc},
856 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, 856 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
857 METH_NOARGS, getdefaultencoding_doc}, 857 METH_NOARGS, getdefaultencoding_doc},
858 #ifdef HAVE_DLOPEN 858 #ifdef HAVE_DLOPEN
859 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, 859 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
860 getdlopenflags_doc}, 860 getdlopenflags_doc},
861 #endif 861 #endif
862 #ifdef COUNT_ALLOCS 862 #ifdef COUNT_ALLOCS
863 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS}, 863 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
864 #endif 864 #endif
865 #ifdef DYNAMIC_EXECUTION_PROFILE 865 #ifdef DYNAMIC_EXECUTION_PROFILE
866 {"getdxp", _Py_GetDXProfile, METH_VARARGS}, 866 {"getdxp", _Py_GetDXProfile, METH_VARARGS},
867 #endif 867 #endif
868 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, 868 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
869 METH_NOARGS, getfilesystemencoding_doc}, 869 METH_NOARGS, getfilesystemencoding_doc},
870 #ifdef Py_TRACE_REFS 870 #ifdef Py_TRACE_REFS
871 {"getobjects", _Py_GetObjects, METH_VARARGS}, 871 {"getobjects", _Py_GetObjects, METH_VARARGS},
872 #endif 872 #endif
873 #ifdef Py_REF_DEBUG 873 #ifdef Py_REF_DEBUG
874 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS}, 874 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
875 #endif 875 #endif
876 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, 876 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
877 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, 877 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
878 getrecursionlimit_doc}, 878 getrecursionlimit_doc},
879 {"getsizeof", (PyCFunction)sys_getsizeof, 879 {"getsizeof", (PyCFunction)sys_getsizeof,
880 METH_VARARGS | METH_KEYWORDS, getsizeof_doc}, 880 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
881 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, 881 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
882 #ifdef MS_WINDOWS 882 #ifdef MS_WINDOWS
883 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, 883 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
884 getwindowsversion_doc}, 884 getwindowsversion_doc},
885 #endif /* MS_WINDOWS */ 885 #endif /* MS_WINDOWS */
886 {"intern", sys_intern, METH_VARARGS, intern_doc}, 886 {"intern", sys_intern, METH_VARARGS, intern_doc},
887 #ifdef USE_MALLOPT 887 #ifdef USE_MALLOPT
888 {"mdebug", sys_mdebug, METH_VARARGS}, 888 {"mdebug", sys_mdebug, METH_VARARGS},
889 #endif 889 #endif
890 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, 890 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
891 setdefaultencoding_doc}, 891 setdefaultencoding_doc},
892 {"setfilesystemencoding", sys_setfilesystemencoding, METH_VARARGS, 892 {"setfilesystemencoding", sys_setfilesystemencoding, METH_VARARGS,
893 setfilesystemencoding_doc}, 893 setfilesystemencoding_doc},
894 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, 894 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
895 setcheckinterval_doc}, 895 setcheckinterval_doc},
896 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS, 896 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
897 getcheckinterval_doc}, 897 getcheckinterval_doc},
898 #ifdef HAVE_DLOPEN 898 #ifdef HAVE_DLOPEN
899 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS, 899 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
900 setdlopenflags_doc}, 900 setdlopenflags_doc},
901 #endif 901 #endif
902 {"setprofile", sys_setprofile, METH_O, setprofile_doc}, 902 {"setprofile", sys_setprofile, METH_O, setprofile_doc},
903 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc}, 903 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
904 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS, 904 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
905 setrecursionlimit_doc}, 905 setrecursionlimit_doc},
906 #ifdef WITH_TSC 906 #ifdef WITH_TSC
907 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc}, 907 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
908 #endif 908 #endif
909 {"settrace", sys_settrace, METH_O, settrace_doc}, 909 {"settrace", sys_settrace, METH_O, settrace_doc},
910 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc}, 910 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
911 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, 911 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
912 {NULL, NULL} /* sentinel */ 912 {NULL, NULL} /* sentinel */
913 }; 913 };
914 914
915 static PyObject * 915 static PyObject *
916 list_builtin_module_names(void) 916 list_builtin_module_names(void)
917 { 917 {
918 PyObject *list = PyList_New(0); 918 PyObject *list = PyList_New(0);
919 int i; 919 int i;
920 if (list == NULL) 920 if (list == NULL)
921 return NULL; 921 return NULL;
922 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 922 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
923 PyObject *name = PyUnicode_FromString( 923 PyObject *name = PyUnicode_FromString(
924 PyImport_Inittab[i].name); 924 PyImport_Inittab[i].name);
925 if (name == NULL) 925 if (name == NULL)
926 break; 926 break;
927 PyList_Append(list, name); 927 PyList_Append(list, name);
928 Py_DECREF(name); 928 Py_DECREF(name);
929 } 929 }
930 if (PyList_Sort(list) != 0) { 930 if (PyList_Sort(list) != 0) {
931 Py_DECREF(list); 931 Py_DECREF(list);
932 list = NULL; 932 list = NULL;
933 } 933 }
934 if (list) { 934 if (list) {
935 PyObject *v = PyList_AsTuple(list); 935 PyObject *v = PyList_AsTuple(list);
936 Py_DECREF(list); 936 Py_DECREF(list);
937 list = v; 937 list = v;
938 } 938 }
939 return list; 939 return list;
940 } 940 }
941 941
942 static PyObject *warnoptions = NULL; 942 static PyObject *warnoptions = NULL;
943 943
944 void 944 void
945 PySys_ResetWarnOptions(void) 945 PySys_ResetWarnOptions(void)
946 { 946 {
947 if (warnoptions == NULL || !PyList_Check(warnoptions)) 947 if (warnoptions == NULL || !PyList_Check(warnoptions))
948 return; 948 return;
949 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 949 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
950 } 950 }
951 951
952 void 952 void
953 PySys_AddWarnOption(const wchar_t *s) 953 PySys_AddWarnOption(const wchar_t *s)
954 { 954 {
955 PyObject *str; 955 PyObject *str;
956 956
957 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 957 if (warnoptions == NULL || !PyList_Check(warnoptions)) {
958 Py_XDECREF(warnoptions); 958 Py_XDECREF(warnoptions);
959 warnoptions = PyList_New(0); 959 warnoptions = PyList_New(0);
960 if (warnoptions == NULL) 960 if (warnoptions == NULL)
961 return; 961 return;
962 } 962 }
963 str = PyUnicode_FromWideChar(s, -1); 963 str = PyUnicode_FromWideChar(s, -1);
964 if (str != NULL) { 964 if (str != NULL) {
965 PyList_Append(warnoptions, str); 965 PyList_Append(warnoptions, str);
966 Py_DECREF(str); 966 Py_DECREF(str);
967 } 967 }
968 } 968 }
969 969
970 int 970 int
971 PySys_HasWarnOptions(void) 971 PySys_HasWarnOptions(void)
972 { 972 {
1074 static const char *svn_revision; 1074 static const char *svn_revision;
1075 1075
1076 static void 1076 static void
1077 svnversion_init(void) 1077 svnversion_init(void)
1078 { 1078 {
1079 const char *python, *br_start, *br_end, *br_end2, *svnversion; 1079 const char *python, *br_start, *br_end, *br_end2, *svnversion;
1080 Py_ssize_t len; 1080 Py_ssize_t len;
1081 int istag = 0; 1081 int istag = 0;
1082 1082
1083 if (svn_initialized) 1083 if (svn_initialized)
1084 return; 1084 return;
1085 1085
1086 python = strstr(headurl, "/python/"); 1086 python = strstr(headurl, "/python/");
1087 if (!python) { 1087 if (!python) {
1088 strcpy(branch, "unknown branch"); 1088 strcpy(branch, "unknown branch");
1089 strcpy(shortbranch, "unknown"); 1089 strcpy(shortbranch, "unknown");
1090 } 1090 }
1091 else { 1091 else {
1092 br_start = python + 8; 1092 br_start = python + 8;
1093 br_end = strchr(br_start, '/'); 1093 br_end = strchr(br_start, '/');
1094 assert(br_end); 1094 assert(br_end);
1095 1095
1096 /* Works even for trunk, 1096 /* Works even for trunk,
1097 as we are in trunk/Python/sysmodule.c */ 1097 as we are in trunk/Python/sysmodule.c */
1098 br_end2 = strchr(br_end+1, '/'); 1098 br_end2 = strchr(br_end+1, '/');
1099 1099
1100 istag = strncmp(br_start, "tags", 4) == 0; 1100 istag = strncmp(br_start, "tags", 4) == 0;
1101 if (strncmp(br_start, "trunk", 5) == 0) { 1101 if (strncmp(br_start, "trunk", 5) == 0) {
1102 strcpy(branch, "trunk"); 1102 strcpy(branch, "trunk");
1103 strcpy(shortbranch, "trunk"); 1103 strcpy(shortbranch, "trunk");
1104 } 1104 }
1105 else if (istag || strncmp(br_start, "branches", 8) == 0) { 1105 else if (istag || strncmp(br_start, "branches", 8) == 0) {
1106 len = br_end2 - br_start; 1106 len = br_end2 - br_start;
1107 strncpy(branch, br_start, len); 1107 strncpy(branch, br_start, len);
1108 branch[len] = '\0'; 1108 branch[len] = '\0';
1109 1109
1110 len = br_end2 - (br_end + 1); 1110 len = br_end2 - (br_end + 1);
1111 strncpy(shortbranch, br_end + 1, len); 1111 strncpy(shortbranch, br_end + 1, len);
1112 shortbranch[len] = '\0'; 1112 shortbranch[len] = '\0';
1113 } 1113 }
1114 else { 1114 else {
1115 Py_FatalError("bad HeadURL"); 1115 Py_FatalError("bad HeadURL");
1116 return; 1116 return;
1117 } 1117 }
1118 } 1118 }
1119 1119
1120 1120
1121 svnversion = _Py_svnversion(); 1121 svnversion = _Py_svnversion();
1122 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0) 1122 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
1123 svn_revision = svnversion; 1123 svn_revision = svnversion;
1124 else if (istag) { 1124 else if (istag) {
1125 len = strlen(_patchlevel_revision); 1125 len = strlen(_patchlevel_revision);
1126 assert(len >= 13); 1126 assert(len >= 13);
1127 assert(len < (sizeof(patchlevel_revision) + 13)); 1127 assert(len < (sizeof(patchlevel_revision) + 13));
1128 strncpy(patchlevel_revision, _patchlevel_revision + 11, 1128 strncpy(patchlevel_revision, _patchlevel_revision + 11,
1129 len - 13); 1129 len - 13);
1130 patchlevel_revision[len - 13] = '\0'; 1130 patchlevel_revision[len - 13] = '\0';
1131 svn_revision = patchlevel_revision; 1131 svn_revision = patchlevel_revision;
1132 } 1132 }
1133 else 1133 else
1134 svn_revision = ""; 1134 svn_revision = "";
1135 1135
1136 svn_initialized = 1; 1136 svn_initialized = 1;
1137 } 1137 }
1138 1138
1139 /* Return svnversion output if available. 1139 /* Return svnversion output if available.
1140 Else return Revision of patchlevel.h if on branch. 1140 Else return Revision of patchlevel.h if on branch.
1141 Else return empty string */ 1141 Else return empty string */
1142 const char* 1142 const char*
1143 Py_SubversionRevision() 1143 Py_SubversionRevision()
1144 { 1144 {
1145 svnversion_init(); 1145 svnversion_init();
1146 return svn_revision; 1146 return svn_revision;
1147 } 1147 }
1148 1148
1149 const char* 1149 const char*
1150 Py_SubversionShortBranch() 1150 Py_SubversionShortBranch()
1151 { 1151 {
1152 svnversion_init(); 1152 svnversion_init();
1153 return shortbranch; 1153 return shortbranch;
1154 } 1154 }
1155 1155
1156 1156
1157 PyDoc_STRVAR(flags__doc__, 1157 PyDoc_STRVAR(flags__doc__,
1158 "sys.flags\n\ 1158 "sys.flags\n\
1160 Flags provided through command line arguments or environment vars."); 1160 Flags provided through command line arguments or environment vars.");
1161 1161
1162 static PyTypeObject FlagsType; 1162 static PyTypeObject FlagsType;
1163 1163
1164 static PyStructSequence_Field flags_fields[] = { 1164 static PyStructSequence_Field flags_fields[] = {
1165 {"debug", "-d"}, 1165 {"debug", "-d"},
1166 {"division_warning", "-Q"}, 1166 {"division_warning", "-Q"},
1167 {"inspect", "-i"}, 1167 {"inspect", "-i"},
1168 {"interactive", "-i"}, 1168 {"interactive", "-i"},
1169 {"optimize", "-O or -OO"}, 1169 {"optimize", "-O or -OO"},
1170 {"dont_write_bytecode", "-B"}, 1170 {"dont_write_bytecode", "-B"},
1171 {"no_user_site", "-s"}, 1171 {"no_user_site", "-s"},
1172 {"no_site", "-S"}, 1172 {"no_site", "-S"},
1173 {"ignore_environment", "-E"}, 1173 {"ignore_environment", "-E"},
1174 {"verbose", "-v"}, 1174 {"verbose", "-v"},
1175 #ifdef RISCOS 1175 #ifdef RISCOS
1176 {"riscos_wimp", "???"}, 1176 {"riscos_wimp", "???"},
1177 #endif 1177 #endif
1178 /* {"unbuffered", "-u"}, */ 1178 /* {"unbuffered", "-u"}, */
1179 /* {"skip_first", "-x"}, */ 1179 /* {"skip_first", "-x"}, */
1180 {"bytes_warning", "-b"}, 1180 {"bytes_warning", "-b"},
1181 {0} 1181 {0}
1182 }; 1182 };
1183 1183
1184 static PyStructSequence_Desc flags_desc = { 1184 static PyStructSequence_Desc flags_desc = {
1185 "sys.flags", /* name */ 1185 "sys.flags", /* name */
1186 flags__doc__, /* doc */ 1186 flags__doc__, /* doc */
1187 flags_fields, /* fields */ 1187 flags_fields, /* fields */
1188 #ifdef RISCOS 1188 #ifdef RISCOS
1189 12 1189 12
1190 #else 1190 #else
1191 11 1191 11
1192 #endif 1192 #endif
1193 }; 1193 };
1194 1194
1195 static PyObject* 1195 static PyObject*
1196 make_flags(void) 1196 make_flags(void)
1197 { 1197 {
1198 int pos = 0; 1198 int pos = 0;
1199 PyObject *seq; 1199 PyObject *seq;
1200 1200
1201 seq = PyStructSequence_New(&FlagsType); 1201 seq = PyStructSequence_New(&FlagsType);
1202 if (seq == NULL) 1202 if (seq == NULL)
1203 return NULL; 1203 return NULL;
1204 1204
1205 #define SetFlag(flag) \ 1205 #define SetFlag(flag) \
1206 PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag)) 1206 PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag))
1207 1207
1208 SetFlag(Py_DebugFlag); 1208 SetFlag(Py_DebugFlag);
1209 SetFlag(Py_DivisionWarningFlag); 1209 SetFlag(Py_DivisionWarningFlag);
1210 SetFlag(Py_InspectFlag); 1210 SetFlag(Py_InspectFlag);
1211 SetFlag(Py_InteractiveFlag); 1211 SetFlag(Py_InteractiveFlag);
1212 SetFlag(Py_OptimizeFlag); 1212 SetFlag(Py_OptimizeFlag);
1213 SetFlag(Py_DontWriteBytecodeFlag); 1213 SetFlag(Py_DontWriteBytecodeFlag);
1214 SetFlag(Py_NoUserSiteDirectory); 1214 SetFlag(Py_NoUserSiteDirectory);
1215 SetFlag(Py_NoSiteFlag); 1215 SetFlag(Py_NoSiteFlag);
1216 SetFlag(Py_IgnoreEnvironmentFlag); 1216 SetFlag(Py_IgnoreEnvironmentFlag);
1217 SetFlag(Py_VerboseFlag); 1217 SetFlag(Py_VerboseFlag);
1218 #ifdef RISCOS 1218 #ifdef RISCOS
1219 SetFlag(Py_RISCOSWimpFlag); 1219 SetFlag(Py_RISCOSWimpFlag);
1220 #endif 1220 #endif
1221 /* SetFlag(saw_unbuffered_flag); */ 1221 /* SetFlag(saw_unbuffered_flag); */
1222 /* SetFlag(skipfirstline); */ 1222 /* SetFlag(skipfirstline); */
1223 SetFlag(Py_BytesWarningFlag); 1223 SetFlag(Py_BytesWarningFlag);
1224 #undef SetFlag 1224 #undef SetFlag
1225 1225
1226 if (PyErr_Occurred()) { 1226 if (PyErr_Occurred()) {
1227 return NULL; 1227 return NULL;
1228 } 1228 }
1229 return seq; 1229 return seq;
1230 } 1230 }
1231 1231
1232 PyDoc_STRVAR(version_info__doc__, 1232 PyDoc_STRVAR(version_info__doc__,
1233 "sys.version_info\n\ 1233 "sys.version_info\n\
1234 \n\ 1234 \n\
1235 Version information as a named tuple."); 1235 Version information as a named tuple.");
1236 1236
1237 static PyTypeObject VersionInfoType; 1237 static PyTypeObject VersionInfoType;
1238 1238
1239 static PyStructSequence_Field version_info_fields[] = { 1239 static PyStructSequence_Field version_info_fields[] = {
1240 {"major", "Major release number"}, 1240 {"major", "Major release number"},
1241 {"minor", "Minor release number"}, 1241 {"minor", "Minor release number"},
1242 {"micro", "Patch release number"}, 1242 {"micro", "Patch release number"},
1243 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"}, 1243 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1244 {"serial", "Serial release number"}, 1244 {"serial", "Serial release number"},
1245 {0} 1245 {0}
1246 }; 1246 };
1247 1247
1248 static PyStructSequence_Desc version_info_desc = { 1248 static PyStructSequence_Desc version_info_desc = {
1249 "sys.version_info", /* name */ 1249 "sys.version_info", /* name */
1250 version_info__doc__, /* doc */ 1250 version_info__doc__, /* doc */
1251 version_info_fields, /* fields */ 1251 version_info_fields, /* fields */
1252 5 1252 5
1253 }; 1253 };
1254 1254
1255 static PyObject * 1255 static PyObject *
1256 make_version_info(void) 1256 make_version_info(void)
1257 { 1257 {
1258 PyObject *version_info; 1258 PyObject *version_info;
1259 char *s; 1259 char *s;
1260 int pos = 0; 1260 int pos = 0;
1261 1261
1262 version_info = PyStructSequence_New(&VersionInfoType); 1262 version_info = PyStructSequence_New(&VersionInfoType);
1263 if (version_info == NULL) { 1263 if (version_info == NULL) {
1264 return NULL; 1264 return NULL;
1265 } 1265 }
1266 1266
1267 /* 1267 /*
1268 * These release level checks are mutually exclusive and cover 1268 * These release level checks are mutually exclusive and cover
1269 * the field, so don't get too fancy with the pre-processor! 1269 * the field, so don't get too fancy with the pre-processor!
1270 */ 1270 */
1271 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1271 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1272 s = "alpha"; 1272 s = "alpha";
1273 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1273 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1274 s = "beta"; 1274 s = "beta";
1275 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1275 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1276 s = "candidate"; 1276 s = "candidate";
1277 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1277 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1278 s = "final"; 1278 s = "final";
1279 #endif 1279 #endif
1280 1280
1281 #define SetIntItem(flag) \ 1281 #define SetIntItem(flag) \
1282 PyStructSequence_SET_ITEM(version_info, pos++, PyLong_FromLong(flag)) 1282 PyStructSequence_SET_ITEM(version_info, pos++, PyLong_FromLong(flag))
1283 #define SetStrItem(flag) \ 1283 #define SetStrItem(flag) \
1284 PyStructSequence_SET_ITEM(version_info, pos++, PyUnicode_FromString(flag)) 1284 PyStructSequence_SET_ITEM(version_info, pos++, PyUnicode_FromString(flag))
1285 1285
1286 SetIntItem(PY_MAJOR_VERSION); 1286 SetIntItem(PY_MAJOR_VERSION);
1287 SetIntItem(PY_MINOR_VERSION); 1287 SetIntItem(PY_MINOR_VERSION);
1288 SetIntItem(PY_MICRO_VERSION); 1288 SetIntItem(PY_MICRO_VERSION);
1289 SetStrItem(s); 1289 SetStrItem(s);
1290 SetIntItem(PY_RELEASE_SERIAL); 1290 SetIntItem(PY_RELEASE_SERIAL);
1291 #undef SetIntItem 1291 #undef SetIntItem
1292 #undef SetStrItem 1292 #undef SetStrItem
1293 1293
1294 if (PyErr_Occurred()) { 1294 if (PyErr_Occurred()) {
1295 Py_CLEAR(version_info); 1295 Py_CLEAR(version_info);
1296 return NULL; 1296 return NULL;
1297 } 1297 }
1298 return version_info; 1298 return version_info;
1299 } 1299 }
1300 1300
1301 static struct PyModuleDef sysmodule = { 1301 static struct PyModuleDef sysmodule = {
1302 PyModuleDef_HEAD_INIT, 1302 PyModuleDef_HEAD_INIT,
1303 "sys", 1303 "sys",
1304 sys_doc, 1304 sys_doc,
1305 -1, /* multiple "initialization" just copies the module dict. */ 1305 -1, /* multiple "initialization" just copies the module dict. */
1306 sys_methods, 1306 sys_methods,
1307 NULL, 1307 NULL,
1308 NULL, 1308 NULL,
1309 NULL, 1309 NULL,
1310 NULL 1310 NULL
1311 }; 1311 };
1312 1312
1313 PyObject * 1313 PyObject *
1314 _PySys_Init(void) 1314 _PySys_Init(void)
1315 { 1315 {
1316 PyObject *m, *v, *sysdict; 1316 PyObject *m, *v, *sysdict;
1317 char *s; 1317 char *s;
1318 1318
1319 m = PyModule_Create(&sysmodule); 1319 m = PyModule_Create(&sysmodule);
1320 if (m == NULL) 1320 if (m == NULL)
1321 return NULL; 1321 return NULL;
1322 sysdict = PyModule_GetDict(m); 1322 sysdict = PyModule_GetDict(m);
1323 #define SET_SYS_FROM_STRING(key, value) \ 1323 #define SET_SYS_FROM_STRING(key, value) \
1324 v = value; \ 1324 v = value; \
1325 if (v != NULL) \ 1325 if (v != NULL) \
1326 PyDict_SetItemString(sysdict, key, v); \ 1326 PyDict_SetItemString(sysdict, key, v); \
1327 Py_XDECREF(v) 1327 Py_XDECREF(v)
1328 1328
1329 /* Check that stdin is not a directory 1329 /* Check that stdin is not a directory
1330 Using shell redirection, you can redirect stdin to a directory, 1330 Using shell redirection, you can redirect stdin to a directory,
1331 crashing the Python interpreter. Catch this common mistake here 1331 crashing the Python interpreter. Catch this common mistake here
1332 and output a useful error message. Note that under MS Windows, 1332 and output a useful error message. Note that under MS Windows,
1333 the shell already prevents that. */ 1333 the shell already prevents that. */
1334 #if !defined(MS_WINDOWS) 1334 #if !defined(MS_WINDOWS)
1335 { 1335 {
1336 struct stat sb; 1336 struct stat sb;
1337 if (fstat(fileno(stdin), &sb) == 0 && 1337 if (fstat(fileno(stdin), &sb) == 0 &&
1338 S_ISDIR(sb.st_mode)) { 1338 S_ISDIR(sb.st_mode)) {
1339 /* There's nothing more we can do. */ 1339 /* There's nothing more we can do. */
1340 /* Py_FatalError() will core dump, so just exit. */ 1340 /* Py_FatalError() will core dump, so just exit. */
1341 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1341 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1342 exit(EXIT_FAILURE); 1342 exit(EXIT_FAILURE);
1343 } 1343 }
1344 } 1344 }
1345 #endif 1345 #endif
1346 1346
1347 /* stdin/stdout/stderr are now set by pythonrun.c */ 1347 /* stdin/stdout/stderr are now set by pythonrun.c */
1348 1348
1349 PyDict_SetItemString(sysdict, "__displayhook__", 1349 PyDict_SetItemString(sysdict, "__displayhook__",
1350 PyDict_GetItemString(sysdict, "displayhook")); 1350 PyDict_GetItemString(sysdict, "displayhook"));
1351 PyDict_SetItemString(sysdict, "__excepthook__", 1351 PyDict_SetItemString(sysdict, "__excepthook__",
1352 PyDict_GetItemString(sysdict, "excepthook")); 1352 PyDict_GetItemString(sysdict, "excepthook"));
1353 SET_SYS_FROM_STRING("version", 1353 SET_SYS_FROM_STRING("version",
1354 PyUnicode_FromString(Py_GetVersion())); 1354 PyUnicode_FromString(Py_GetVersion()));
1355 SET_SYS_FROM_STRING("hexversion", 1355 SET_SYS_FROM_STRING("hexversion",
1356 PyLong_FromLong(PY_VERSION_HEX)); 1356 PyLong_FromLong(PY_VERSION_HEX));
1357 svnversion_init(); 1357 svnversion_init();
1358 SET_SYS_FROM_STRING("subversion", 1358 SET_SYS_FROM_STRING("subversion",
1359 Py_BuildValue("(UUU)", "CPython", branch, 1359 Py_BuildValue("(UUU)", "CPython", branch,
1360 svn_revision)); 1360 svn_revision));
1361 SET_SYS_FROM_STRING("dont_write_bytecode", 1361 SET_SYS_FROM_STRING("dont_write_bytecode",
1362 PyBool_FromLong(Py_DontWriteBytecodeFlag)); 1362 PyBool_FromLong(Py_DontWriteBytecodeFlag));
1363 SET_SYS_FROM_STRING("api_version", 1363 SET_SYS_FROM_STRING("api_version",
1364 PyLong_FromLong(PYTHON_API_VERSION)); 1364 PyLong_FromLong(PYTHON_API_VERSION));
1365 SET_SYS_FROM_STRING("copyright", 1365 SET_SYS_FROM_STRING("copyright",
1366 PyUnicode_FromString(Py_GetCopyright())); 1366 PyUnicode_FromString(Py_GetCopyright()));
1367 SET_SYS_FROM_STRING("platform", 1367 SET_SYS_FROM_STRING("platform",
1368 PyUnicode_FromString(Py_GetPlatform())); 1368 PyUnicode_FromString(Py_GetPlatform()));
1369 SET_SYS_FROM_STRING("executable", 1369 SET_SYS_FROM_STRING("executable",
1370 PyUnicode_FromWideChar( 1370 PyUnicode_FromWideChar(
1371 Py_GetProgramFullPath(), -1)); 1371 Py_GetProgramFullPath(), -1));
1372 SET_SYS_FROM_STRING("prefix", 1372 SET_SYS_FROM_STRING("prefix",
1373 PyUnicode_FromWideChar(Py_GetPrefix(), -1)); 1373 PyUnicode_FromWideChar(Py_GetPrefix(), -1));
1374 SET_SYS_FROM_STRING("exec_prefix", 1374 SET_SYS_FROM_STRING("exec_prefix",
1375 PyUnicode_FromWideChar(Py_GetExecPrefix(), -1)); 1375 PyUnicode_FromWideChar(Py_GetExecPrefix(), -1));
1376 SET_SYS_FROM_STRING("maxsize", 1376 SET_SYS_FROM_STRING("maxsize",
1377 PyLong_FromSsize_t(PY_SSIZE_T_MAX)); 1377 PyLong_FromSsize_t(PY_SSIZE_T_MAX));
1378 SET_SYS_FROM_STRING("float_info", 1378 SET_SYS_FROM_STRING("float_info",
1379 PyFloat_GetInfo()); 1379 PyFloat_GetInfo());
1380 SET_SYS_FROM_STRING("int_info", 1380 SET_SYS_FROM_STRING("int_info",
1381 PyLong_GetInfo()); 1381 PyLong_GetInfo());
1382 SET_SYS_FROM_STRING("maxunicode", 1382 SET_SYS_FROM_STRING("maxunicode",
1383 PyLong_FromLong(PyUnicode_GetMax())); 1383 PyLong_FromLong(PyUnicode_GetMax()));
1384 SET_SYS_FROM_STRING("builtin_module_names", 1384 SET_SYS_FROM_STRING("builtin_module_names",
1385 list_builtin_module_names()); 1385 list_builtin_module_names());
1386 { 1386 {
1387 /* Assumes that longs are at least 2 bytes long. 1387 /* Assumes that longs are at least 2 bytes long.
1388 Should be safe! */ 1388 Should be safe! */
1389 unsigned long number = 1; 1389 unsigned long number = 1;
1390 char *value; 1390 char *value;
1391 1391
1392 s = (char *) &number; 1392 s = (char *) &number;
1393 if (s[0] == 0) 1393 if (s[0] == 0)
1394 value = "big"; 1394 value = "big";
1395 else 1395 else
1396 value = "little"; 1396 value = "little";
1397 SET_SYS_FROM_STRING("byteorder", 1397 SET_SYS_FROM_STRING("byteorder",
1398 PyUnicode_FromString(value)); 1398 PyUnicode_FromString(value));
1399 } 1399 }
1400 #ifdef MS_COREDLL 1400 #ifdef MS_COREDLL
1401 SET_SYS_FROM_STRING("dllhandle", 1401 SET_SYS_FROM_STRING("dllhandle",
1402 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1402 PyLong_FromVoidPtr(PyWin_DLLhModule));
1403 SET_SYS_FROM_STRING("winver", 1403 SET_SYS_FROM_STRING("winver",
1404 PyUnicode_FromString(PyWin_DLLVersionString)); 1404 PyUnicode_FromString(PyWin_DLLVersionString));
1405 #endif 1405 #endif
1406 if (warnoptions == NULL) { 1406 if (warnoptions == NULL) {
1407 warnoptions = PyList_New(0); 1407 warnoptions = PyList_New(0);
1408 } 1408 }
1409 else { 1409 else {
1410 Py_INCREF(warnoptions); 1410 Py_INCREF(warnoptions);
1411 } 1411 }
1412 if (warnoptions != NULL) { 1412 if (warnoptions != NULL) {
1413 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1413 PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1414 } 1414 }
1415 1415
1416 /* version_info */ 1416 /* version_info */
1417 if (VersionInfoType.tp_name == 0) 1417 if (VersionInfoType.tp_name == 0)
1418 PyStructSequence_InitType(&VersionInfoType, &version_info_desc); 1418 PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1419 SET_SYS_FROM_STRING("version_info", make_version_info()); 1419 SET_SYS_FROM_STRING("version_info", make_version_info());
1420 /* prevent user from creating new instances */ 1420 /* prevent user from creating new instances */
1421 VersionInfoType.tp_init = NULL; 1421 VersionInfoType.tp_init = NULL;
1422 VersionInfoType.tp_new = NULL; 1422 VersionInfoType.tp_new = NULL;
1423 1423
1424 /* flags */ 1424 /* flags */
1425 if (FlagsType.tp_name == 0) 1425 if (FlagsType.tp_name == 0)
1426 PyStructSequence_InitType(&FlagsType, &flags_desc); 1426 PyStructSequence_InitType(&FlagsType, &flags_desc);
1427 SET_SYS_FROM_STRING("flags", make_flags()); 1427 SET_SYS_FROM_STRING("flags", make_flags());
1428 /* prevent user from creating new instances */ 1428 /* prevent user from creating new instances */
1429 FlagsType.tp_init = NULL; 1429 FlagsType.tp_init = NULL;
1430 FlagsType.tp_new = NULL; 1430 FlagsType.tp_new = NULL;
1431 1431
1432 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */ 1432 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1433 #ifndef PY_NO_SHORT_FLOAT_REPR 1433 #ifndef PY_NO_SHORT_FLOAT_REPR
1434 SET_SYS_FROM_STRING("float_repr_style", 1434 SET_SYS_FROM_STRING("float_repr_style",
1435 PyUnicode_FromString("short")); 1435 PyUnicode_FromString("short"));
1436 #else 1436 #else
1437 SET_SYS_FROM_STRING("float_repr_style", 1437 SET_SYS_FROM_STRING("float_repr_style",
1438 PyUnicode_FromString("legacy")); 1438 PyUnicode_FromString("legacy"));
1439 #endif 1439 #endif
1440 1440
1441 #undef SET_SYS_FROM_STRING 1441 #undef SET_SYS_FROM_STRING
1442 if (PyErr_Occurred()) 1442 if (PyErr_Occurred())
1443 return NULL; 1443 return NULL;
1444 return m; 1444 return m;
1445 } 1445 }
1446 1446
1447 static PyObject * 1447 static PyObject *
1448 makepathobject(const wchar_t *path, wchar_t delim) 1448 makepathobject(const wchar_t *path, wchar_t delim)
1449 { 1449 {
1450 int i, n; 1450 int i, n;
1451 const wchar_t *p; 1451 const wchar_t *p;
1452 PyObject *v, *w; 1452 PyObject *v, *w;
1453 1453
1454 n = 1; 1454 n = 1;
1455 p = path; 1455 p = path;
1456 while ((p = wcschr(p, delim)) != NULL) { 1456 while ((p = wcschr(p, delim)) != NULL) {
1457 n++; 1457 n++;
1458 p++; 1458 p++;
1459 } 1459 }
1460 v = PyList_New(n); 1460 v = PyList_New(n);
1461 if (v == NULL) 1461 if (v == NULL)
1462 return NULL; 1462 return NULL;
1463 for (i = 0; ; i++) { 1463 for (i = 0; ; i++) {
1464 p = wcschr(path, delim); 1464 p = wcschr(path, delim);
1465 if (p == NULL) 1465 if (p == NULL)
1466 p = path + wcslen(path); /* End of string */ 1466 p = path + wcslen(path); /* End of string */
1467 w = PyUnicode_FromWideChar(path, (Py_ssize_t)(p - path)); 1467 w = PyUnicode_FromWideChar(path, (Py_ssize_t)(p - path));
1468 if (w == NULL) { 1468 if (w == NULL) {
1469 Py_DECREF(v); 1469 Py_DECREF(v);
1470 return NULL; 1470 return NULL;
1471 } 1471 }
1472 PyList_SetItem(v, i, w); 1472 PyList_SetItem(v, i, w);
1473 if (*p == '\0') 1473 if (*p == '\0')
1474 break; 1474 break;
1475 path = p+1; 1475 path = p+1;
1476 } 1476 }
1477 return v; 1477 return v;
1478 } 1478 }
1479 1479
1480 void 1480 void
1481 PySys_SetPath(const wchar_t *path) 1481 PySys_SetPath(const wchar_t *path)
1482 { 1482 {
1483 PyObject *v; 1483 PyObject *v;
1484 if ((v = makepathobject(path, DELIM)) == NULL) 1484 if ((v = makepathobject(path, DELIM)) == NULL)
1485 Py_FatalError("can't create sys.path"); 1485 Py_FatalError("can't create sys.path");
1486 if (PySys_SetObject("path", v) != 0) 1486 if (PySys_SetObject("path", v) != 0)
1487 Py_FatalError("can't assign sys.path"); 1487 Py_FatalError("can't assign sys.path");
1488 Py_DECREF(v); 1488 Py_DECREF(v);
1489 } 1489 }
1490 1490
1491 static PyObject * 1491 static PyObject *
1492 makeargvobject(int argc, wchar_t **argv) 1492 makeargvobject(int argc, wchar_t **argv)
1493 { 1493 {
1494 PyObject *av; 1494 PyObject *av;
1495 if (argc <= 0 || argv == NULL) { 1495 if (argc <= 0 || argv == NULL) {
1496 /* Ensure at least one (empty) argument is seen */ 1496 /* Ensure at least one (empty) argument is seen */
1497 static wchar_t *empty_argv[1] = {L""}; 1497 static wchar_t *empty_argv[1] = {L""};
1498 argv = empty_argv; 1498 argv = empty_argv;
1499 argc = 1; 1499 argc = 1;
1500 } 1500 }
1501 av = PyList_New(argc); 1501 av = PyList_New(argc);
1502 if (av != NULL) { 1502 if (av != NULL) {
1503 int i; 1503 int i;
1504 for (i = 0; i < argc; i++) { 1504 for (i = 0; i < argc; i++) {
1505 #ifdef __VMS 1505 #ifdef __VMS
1506 PyObject *v; 1506 PyObject *v;
1507 1507
1508 /* argv[0] is the script pathname if known */ 1508 /* argv[0] is the script pathname if known */
1509 if (i == 0) { 1509 if (i == 0) {
1510 char* fn = decc$translate_vms(argv[0]); 1510 char* fn = decc$translate_vms(argv[0]);
1511 if ((fn == (char *)0) || fn == (char *)-1) 1511 if ((fn == (char *)0) || fn == (char *)-1)
1512 v = PyUnicode_FromString(argv[0]); 1512 v = PyUnicode_FromString(argv[0]);
1513 else 1513 else
1514 v = PyUnicode_FromString( 1514 v = PyUnicode_FromString(
1515 decc$translate_vms(argv[0])); 1515 decc$translate_vms(argv[0]));
1516 } else 1516 } else
1517 v = PyUnicode_FromString(argv[i]); 1517 v = PyUnicode_FromString(argv[i]);
1518 #else 1518 #else
1519 PyObject *v = PyUnicode_FromWideChar(argv[i], -1); 1519 PyObject *v = PyUnicode_FromWideChar(argv[i], -1);
1520 #endif 1520 #endif
1521 if (v == NULL) { 1521 if (v == NULL) {
1522 Py_DECREF(av); 1522 Py_DECREF(av);
1523 av = NULL; 1523 av = NULL;
1524 break; 1524 break;
1525 } 1525 }
1526 PyList_SetItem(av, i, v); 1526 PyList_SetItem(av, i, v);
1527 } 1527 }
1528 } 1528 }
1529 return av; 1529 return av;
1530 } 1530 }
1531 1531
1532 #ifdef HAVE_REALPATH 1532 #ifdef HAVE_REALPATH
1533 static wchar_t* 1533 static wchar_t*
1534 _wrealpath(const wchar_t *path, wchar_t *resolved_path) 1534 _wrealpath(const wchar_t *path, wchar_t *resolved_path)
1535 { 1535 {
1536 char cpath[PATH_MAX]; 1536 char cpath[PATH_MAX];
1537 char cresolved_path[PATH_MAX]; 1537 char cresolved_path[PATH_MAX];
1538 char *res; 1538 char *res;
1539 size_t r; 1539 size_t r;
1540 r = wcstombs(cpath, path, PATH_MAX); 1540 r = wcstombs(cpath, path, PATH_MAX);
1541 if (r == (size_t)-1 || r >= PATH_MAX) { 1541 if (r == (size_t)-1 || r >= PATH_MAX) {
1542 errno = EINVAL; 1542 errno = EINVAL;
1543 return NULL; 1543 return NULL;
1544 } 1544 }
1545 res = realpath(cpath, cresolved_path); 1545 res = realpath(cpath, cresolved_path);
1546 if (res == NULL) 1546 if (res == NULL)
1547 return NULL; 1547 return NULL;
1548 r = mbstowcs(resolved_path, cresolved_path, PATH_MAX); 1548 r = mbstowcs(resolved_path, cresolved_path, PATH_MAX);
1549 if (r == (size_t)-1 || r >= PATH_MAX) { 1549 if (r == (size_t)-1 || r >= PATH_MAX) {
1550 errno = EINVAL; 1550 errno = EINVAL;
1551 return NULL; 1551 return NULL;
1552 } 1552 }
1553 return resolved_path; 1553 return resolved_path;
1554 } 1554 }
1555 #endif 1555 #endif
1556 1556
1557 void 1557 void
1558 PySys_SetArgv(int argc, wchar_t **argv) 1558 PySys_SetArgv(int argc, wchar_t **argv)
1559 { 1559 {
1560 #if defined(HAVE_REALPATH) 1560 #if defined(HAVE_REALPATH)
1561 wchar_t fullpath[MAXPATHLEN]; 1561 wchar_t fullpath[MAXPATHLEN];
1562 #elif defined(MS_WINDOWS) && !defined(MS_WINCE) 1562 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1563 wchar_t fullpath[MAX_PATH]; 1563 wchar_t fullpath[MAX_PATH];
1564 #endif 1564 #endif
1565 PyObject *av = makeargvobject(argc, argv); 1565 PyObject *av = makeargvobject(argc, argv);
1566 PyObject *path = PySys_GetObject("path"); 1566 PyObject *path = PySys_GetObject("path");
1567 if (av == NULL) 1567 if (av == NULL)
1568 Py_FatalError("no mem for sys.argv"); 1568 Py_FatalError("no mem for sys.argv");
1569 if (PySys_SetObject("argv", av) != 0) 1569 if (PySys_SetObject("argv", av) != 0)
1570 Py_FatalError("can't assign sys.argv"); 1570 Py_FatalError("can't assign sys.argv");
1571 if (path != NULL) { 1571 if (path != NULL) {
1572 wchar_t *argv0 = argv[0]; 1572 wchar_t *argv0 = argv[0];
1573 wchar_t *p = NULL; 1573 wchar_t *p = NULL;
1574 Py_ssize_t n = 0; 1574 Py_ssize_t n = 0;
1575 PyObject *a; 1575 PyObject *a;
1576 extern int _Py_wreadlink(const wchar_t *, wchar_t *, size_t); 1576 extern int _Py_wreadlink(const wchar_t *, wchar_t *, size_t);
1577 #ifdef HAVE_READLINK 1577 #ifdef HAVE_READLINK
1578 wchar_t link[MAXPATHLEN+1]; 1578 wchar_t link[MAXPATHLEN+1];
1579 wchar_t argv0copy[2*MAXPATHLEN+1]; 1579 wchar_t argv0copy[2*MAXPATHLEN+1];
1580 int nr = 0; 1580 int nr = 0;
1581 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) 1581 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0)
1582 nr = _Py_wreadlink(argv0, link, MAXPATHLEN); 1582 nr = _Py_wreadlink(argv0, link, MAXPATHLEN);
1583 if (nr > 0) { 1583 if (nr > 0) {
1584 /* It's a symlink */ 1584 /* It's a symlink */
1585 link[nr] = '\0'; 1585 link[nr] = '\0';
1586 if (link[0] == SEP) 1586 if (link[0] == SEP)
1587 argv0 = link; /* Link to absolute path */ 1587 argv0 = link; /* Link to absolute path */
1588 else if (wcschr(link, SEP) == NULL) 1588 else if (wcschr(link, SEP) == NULL)
1589 ; /* Link without path */ 1589 ; /* Link without path */
1590 else { 1590 else {
1591 /* Must join(dirname(argv0), link) */ 1591 /* Must join(dirname(argv0), link) */
1592 wchar_t *q = wcsrchr(argv0, SEP); 1592 wchar_t *q = wcsrchr(argv0, SEP);
1593 if (q == NULL) 1593 if (q == NULL)
1594 argv0 = link; /* argv0 without path */ 1594 argv0 = link; /* argv0 without path */
1595 else { 1595 else {
1596 /* Must make a copy */ 1596 /* Must make a copy */
1597 wcscpy(argv0copy, argv0); 1597 wcscpy(argv0copy, argv0);
1598 q = wcsrchr(argv0copy, SEP); 1598 q = wcsrchr(argv0copy, SEP);
1599 wcscpy(q+1, link); 1599 wcscpy(q+1, link);
1600 argv0 = argv0copy; 1600 argv0 = argv0copy;
1601 } 1601 }
1602 } 1602 }
1603 } 1603 }
1604 #endif /* HAVE_READLINK */ 1604 #endif /* HAVE_READLINK */
1605 #if SEP == '\\' /* Special case for MS filename syntax */ 1605 #if SEP == '\\' /* Special case for MS filename syntax */
1606 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) { 1606 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) {
1607 wchar_t *q; 1607 wchar_t *q;
1608 #if defined(MS_WINDOWS) && !defined(MS_WINCE) 1608 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1609 /* This code here replaces the first element in argv with the full 1609 /* This code here replaces the first element in argv with the full
1610 path that it represents. Under CE, there are no relative paths so 1610 path that it represents. Under CE, there are no relative paths so
1611 the argument must be the full path anyway. */ 1611 the argument must be the full path anyway. */
1612 wchar_t *ptemp; 1612 wchar_t *ptemp;
1613 if (GetFullPathNameW(argv0, 1613 if (GetFullPathNameW(argv0,
1614 sizeof(fullpath)/sizeof(fullpath[0]), 1614 sizeof(fullpath)/sizeof(fullpath[0]),
1615 fullpath, 1615 fullpath,
1616 &ptemp)) { 1616 &ptemp)) {
1617 argv0 = fullpath; 1617 argv0 = fullpath;
1618 } 1618 }
1619 #endif 1619 #endif
1620 p = wcsrchr(argv0, SEP); 1620 p = wcsrchr(argv0, SEP);
1621 /* Test for alternate separator */ 1621 /* Test for alternate separator */
1622 q = wcsrchr(p ? p : argv0, '/'); 1622 q = wcsrchr(p ? p : argv0, '/');
1623 if (q != NULL) 1623 if (q != NULL)
1624 p = q; 1624 p = q;
1625 if (p != NULL) { 1625 if (p != NULL) {
1626 n = p + 1 - argv0; 1626 n = p + 1 - argv0;
1627 if (n > 1 && p[-1] != ':') 1627 if (n > 1 && p[-1] != ':')
1628 n--; /* Drop trailing separator */ 1628 n--; /* Drop trailing separator */
1629 } 1629 }
1630 } 1630 }
1631 #else /* All other filename syntaxes */ 1631 #else /* All other filename syntaxes */
1632 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) { 1632 if (argc > 0 && argv0 != NULL && wcscmp(argv0, L"-c") != 0) {
1633 #if defined(HAVE_REALPATH) 1633 #if defined(HAVE_REALPATH)
1634 if (_wrealpath(argv0, fullpath)) { 1634 if (_wrealpath(argv0, fullpath)) {
1635 argv0 = fullpath; 1635 argv0 = fullpath;
1636 } 1636 }
1637 #endif 1637 #endif
1638 p = wcsrchr(argv0, SEP); 1638 p = wcsrchr(argv0, SEP);
1639 } 1639 }
1640 if (p != NULL) { 1640 if (p != NULL) {
1641 n = p + 1 - argv0; 1641 n = p + 1 - argv0;
1642 #if SEP == '/' /* Special case for Unix filename syntax */ 1642 #if SEP == '/' /* Special case for Unix filename syntax */
1643 if (n > 1) 1643 if (n > 1)
1644 n--; /* Drop trailing separator */ 1644 n--; /* Drop trailing separator */
1645 #endif /* Unix */ 1645 #endif /* Unix */
1646 } 1646 }
1647 #endif /* All others */ 1647 #endif /* All others */
1648 a = PyUnicode_FromWideChar(argv0, n); 1648 a = PyUnicode_FromWideChar(argv0, n);
1649 if (a == NULL) 1649 if (a == NULL)
1650 Py_FatalError("no mem for sys.path insertion"); 1650 Py_FatalError("no mem for sys.path insertion");
1651 if (PyList_Insert(path, 0, a) < 0) 1651 if (PyList_Insert(path, 0, a) < 0)
1652 Py_FatalError("sys.path.insert(0) failed"); 1652 Py_FatalError("sys.path.insert(0) failed");
1653 Py_DECREF(a); 1653 Py_DECREF(a);
1654 } 1654 }
1655 Py_DECREF(av); 1655 Py_DECREF(av);
1656 } 1656 }
1657 1657
1658 /* Reimplementation of PyFile_WriteString() no calling indirectly 1658 /* Reimplementation of PyFile_WriteString() no calling indirectly
1659 PyErr_CheckSignals(): avoid the call to PyObject_Str(). */ 1659 PyErr_CheckSignals(): avoid the call to PyObject_Str(). */
1660 1660
1661 static int 1661 static int
1662 sys_pyfile_write(const char *text, PyObject *file) 1662 sys_pyfile_write(const char *text, PyObject *file)
1663 { 1663 {
1664 PyObject *unicode = NULL, *writer = NULL, *args = NULL, *result = NULL; 1664 PyObject *unicode = NULL, *writer = NULL, *args = NULL, *result = NULL;
1665 int err; 1665 int err;
1666 1666
1667 unicode = PyUnicode_FromString(text); 1667 unicode = PyUnicode_FromString(text);
1668 if (unicode == NULL) 1668 if (unicode == NULL)
1669 goto error; 1669 goto error;
1670 1670
1671 writer = PyObject_GetAttrString(file, "write"); 1671 writer = PyObject_GetAttrString(file, "write");
1672 if (writer == NULL) 1672 if (writer == NULL)
1673 goto error; 1673 goto error;
1674 1674
1675 args = PyTuple_Pack(1, unicode); 1675 args = PyTuple_Pack(1, unicode);
1676 if (args == NULL) 1676 if (args == NULL)
1677 goto error; 1677 goto error;
1678 1678
1679 result = PyEval_CallObject(writer, args); 1679 result = PyEval_CallObject(writer, args);
1680 if (result == NULL) { 1680 if (result == NULL) {
1681 goto error; 1681 goto error;
1682 } else { 1682 } else {
1683 err = 0; 1683 err = 0;
1684 goto finally; 1684 goto finally;
1685 } 1685 }
1686 1686
1687 error: 1687 error:
1688 err = -1; 1688 err = -1;
1689 finally: 1689 finally:
1690 Py_XDECREF(unicode); 1690 Py_XDECREF(unicode);
1691 Py_XDECREF(writer); 1691 Py_XDECREF(writer);
1692 Py_XDECREF(args); 1692 Py_XDECREF(args);
1693 Py_XDECREF(result); 1693 Py_XDECREF(result);
1694 return err; 1694 return err;
1695 } 1695 }
1696 1696
1697 1697
1698 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface. 1698 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1699 Adapted from code submitted by Just van Rossum. 1699 Adapted from code submitted by Just van Rossum.
1724 */ 1724 */
1725 1725
1726 static void 1726 static void
1727 mywrite(char *name, FILE *fp, const char *format, va_list va) 1727 mywrite(char *name, FILE *fp, const char *format, va_list va)
1728 { 1728 {
1729 PyObject *file; 1729 PyObject *file;
1730 PyObject *error_type, *error_value, *error_traceback; 1730 PyObject *error_type, *error_value, *error_traceback;
1731 char buffer[1001]; 1731 char buffer[1001];
1732 int written; 1732 int written;
1733 1733
1734 PyErr_Fetch(&error_type, &error_value, &error_traceback); 1734 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1735 file = PySys_GetObject(name); 1735 file = PySys_GetObject(name);
1736 written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va); 1736 written = PyOS_vsnprintf(buffer, sizeof(buffer), format, va);
1737 if (sys_pyfile_write(buffer, file) != 0) { 1737 if (sys_pyfile_write(buffer, file) != 0) {
1738 PyErr_Clear(); 1738 PyErr_Clear();
1739 fputs(buffer, fp); 1739 fputs(buffer, fp);
1740 } 1740 }
1741 if (written < 0 || (size_t)written >= sizeof(buffer)) { 1741 if (written < 0 || (size_t)written >= sizeof(buffer)) {
1742 const char *truncated = "... truncated"; 1742 const char *truncated = "... truncated";
1743 if (sys_pyfile_write(truncated, file) != 0) { 1743 if (sys_pyfile_write(truncated, file) != 0) {
1744 PyErr_Clear(); 1744 PyErr_Clear();
1745 fputs(truncated, fp); 1745 fputs(truncated, fp);
1746 } 1746 }
1747 } 1747 }
1748 PyErr_Restore(error_type, error_value, error_traceback); 1748 PyErr_Restore(error_type, error_value, error_traceback);
1749 } 1749 }
1750 1750
1751 void 1751 void
1752 PySys_WriteStdout(const char *format, ...) 1752 PySys_WriteStdout(const char *format, ...)
1753 { 1753 {
1754 va_list va; 1754 va_list va;
1755 1755
1756 va_start(va, format); 1756 va_start(va, format);
1757 mywrite("stdout", stdout, format, va); 1757 mywrite("stdout", stdout, format, va);
1758 va_end(va); 1758 va_end(va);
1759 } 1759 }
1760 1760
1761 void 1761 void
1762 PySys_WriteStderr(const char *format, ...) 1762 PySys_WriteStderr(const char *format, ...)
1763 { 1763 {
1764 va_list va; 1764 va_list va;
1765 1765
1766 va_start(va, format); 1766 va_start(va, format);
1767 mywrite("stderr", stderr, format, va); 1767 mywrite("stderr", stderr, format, va);
1768 va_end(va); 1768 va_end(va);
1769 } 1769 }