Mercurial > cpython-lru_cache-weakref

comparison Python/sysmodule.c @ 61465:e38335d4df91 2.6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 15:15:40 +0000
parents 5bb295a94b0f
children 3f08d98c8fa5
comparison
equal deleted inserted replaced
61461:b6e03ca8a206 61465:e38335d4df91
47 #endif 47 #endif
48 48
49 PyObject * 49 PyObject *
50 PySys_GetObject(char *name) 50 PySys_GetObject(char *name)
51 { 51 {
52 PyThreadState *tstate = PyThreadState_GET(); 52 PyThreadState *tstate = PyThreadState_GET();
53 PyObject *sd = tstate->interp->sysdict; 53 PyObject *sd = tstate->interp->sysdict;
54 if (sd == NULL) 54 if (sd == NULL)
55 return NULL; 55 return NULL;
56 return PyDict_GetItemString(sd, name); 56 return PyDict_GetItemString(sd, name);
57 } 57 }
58 58
59 FILE * 59 FILE *
60 PySys_GetFile(char *name, FILE *def) 60 PySys_GetFile(char *name, FILE *def)
61 { 61 {
62 FILE *fp = NULL; 62 FILE *fp = NULL;
63 PyObject *v = PySys_GetObject(name); 63 PyObject *v = PySys_GetObject(name);
64 if (v != NULL && PyFile_Check(v)) 64 if (v != NULL && PyFile_Check(v))
65 fp = PyFile_AsFile(v); 65 fp = PyFile_AsFile(v);
66 if (fp == NULL) 66 if (fp == NULL)
67 fp = def; 67 fp = def;
68 return fp; 68 return fp;
69 } 69 }
70 70
71 int 71 int
72 PySys_SetObject(char *name, PyObject *v) 72 PySys_SetObject(char *name, PyObject *v)
73 { 73 {
74 PyThreadState *tstate = PyThreadState_GET(); 74 PyThreadState *tstate = PyThreadState_GET();
75 PyObject *sd = tstate->interp->sysdict; 75 PyObject *sd = tstate->interp->sysdict;
76 if (v == NULL) { 76 if (v == NULL) {
77 if (PyDict_GetItemString(sd, name) == NULL) 77 if (PyDict_GetItemString(sd, name) == NULL)
78 return 0; 78 return 0;
79 else 79 else
80 return PyDict_DelItemString(sd, name); 80 return PyDict_DelItemString(sd, name);
81 } 81 }
82 else 82 else
83 return PyDict_SetItemString(sd, name, v); 83 return PyDict_SetItemString(sd, name, v);
84 } 84 }
85 85
86 static PyObject * 86 static PyObject *
87 sys_displayhook(PyObject *self, PyObject *o) 87 sys_displayhook(PyObject *self, PyObject *o)
88 { 88 {
89 PyObject *outf; 89 PyObject *outf;
90 PyInterpreterState *interp = PyThreadState_GET()->interp; 90 PyInterpreterState *interp = PyThreadState_GET()->interp;
91 PyObject *modules = interp->modules; 91 PyObject *modules = interp->modules;
92 PyObject *builtins = PyDict_GetItemString(modules, "__builtin__"); 92 PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
93 93
94 if (builtins == NULL) { 94 if (builtins == NULL) {
95 PyErr_SetString(PyExc_RuntimeError, "lost __builtin__"); 95 PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
96 return NULL; 96 return NULL;
97 } 97 }
98 98
99 /* Print value except if None */ 99 /* Print value except if None */
100 /* After printing, also assign to '_' */ 100 /* After printing, also assign to '_' */
101 /* Before, set '_' to None to avoid recursion */ 101 /* Before, set '_' to None to avoid recursion */
102 if (o == Py_None) { 102 if (o == Py_None) {
103 Py_INCREF(Py_None); 103 Py_INCREF(Py_None);
104 return Py_None; 104 return Py_None;
105 } 105 }
106 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0) 106 if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
107 return NULL; 107 return NULL;
108 if (Py_FlushLine() != 0) 108 if (Py_FlushLine() != 0)
109 return NULL; 109 return NULL;
110 outf = PySys_GetObject("stdout"); 110 outf = PySys_GetObject("stdout");
111 if (outf == NULL) { 111 if (outf == NULL) {
112 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); 112 PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
113 return NULL; 113 return NULL;
114 } 114 }
115 if (PyFile_WriteObject(o, outf, 0) != 0) 115 if (PyFile_WriteObject(o, outf, 0) != 0)
116 return NULL; 116 return NULL;
117 PyFile_SoftSpace(outf, 1); 117 PyFile_SoftSpace(outf, 1);
118 if (Py_FlushLine() != 0) 118 if (Py_FlushLine() != 0)
119 return NULL; 119 return NULL;
120 if (PyObject_SetAttrString(builtins, "_", o) != 0) 120 if (PyObject_SetAttrString(builtins, "_", o) != 0)
121 return NULL; 121 return NULL;
122 Py_INCREF(Py_None); 122 Py_INCREF(Py_None);
123 return Py_None; 123 return Py_None;
124 } 124 }
125 125
126 PyDoc_STRVAR(displayhook_doc, 126 PyDoc_STRVAR(displayhook_doc,
127 "displayhook(object) -> None\n" 127 "displayhook(object) -> None\n"
128 "\n" 128 "\n"
130 ); 130 );
131 131
132 static PyObject * 132 static PyObject *
133 sys_excepthook(PyObject* self, PyObject* args) 133 sys_excepthook(PyObject* self, PyObject* args)
134 { 134 {
135 PyObject *exc, *value, *tb; 135 PyObject *exc, *value, *tb;
136 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb)) 136 if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
137 return NULL; 137 return NULL;
138 PyErr_Display(exc, value, tb); 138 PyErr_Display(exc, value, tb);
139 Py_INCREF(Py_None); 139 Py_INCREF(Py_None);
140 return Py_None; 140 return Py_None;
141 } 141 }
142 142
143 PyDoc_STRVAR(excepthook_doc, 143 PyDoc_STRVAR(excepthook_doc,
144 "excepthook(exctype, value, traceback) -> None\n" 144 "excepthook(exctype, value, traceback) -> None\n"
145 "\n" 145 "\n"
147 ); 147 );
148 148
149 static PyObject * 149 static PyObject *
150 sys_exc_info(PyObject *self, PyObject *noargs) 150 sys_exc_info(PyObject *self, PyObject *noargs)
151 { 151 {
152 PyThreadState *tstate; 152 PyThreadState *tstate;
153 tstate = PyThreadState_GET(); 153 tstate = PyThreadState_GET();
154 return Py_BuildValue( 154 return Py_BuildValue(
155 "(OOO)", 155 "(OOO)",
156 tstate->exc_type != NULL ? tstate->exc_type : Py_None, 156 tstate->exc_type != NULL ? tstate->exc_type : Py_None,
157 tstate->exc_value != NULL ? tstate->exc_value : Py_None, 157 tstate->exc_value != NULL ? tstate->exc_value : Py_None,
158 tstate->exc_traceback != NULL ? 158 tstate->exc_traceback != NULL ?
159 tstate->exc_traceback : Py_None); 159 tstate->exc_traceback : Py_None);
160 } 160 }
161 161
162 PyDoc_STRVAR(exc_info_doc, 162 PyDoc_STRVAR(exc_info_doc,
163 "exc_info() -> (type, value, traceback)\n\ 163 "exc_info() -> (type, value, traceback)\n\
164 \n\ 164 \n\
167 ); 167 );
168 168
169 static PyObject * 169 static PyObject *
170 sys_exc_clear(PyObject *self, PyObject *noargs) 170 sys_exc_clear(PyObject *self, PyObject *noargs)
171 { 171 {
172 PyThreadState *tstate; 172 PyThreadState *tstate;
173 PyObject *tmp_type, *tmp_value, *tmp_tb; 173 PyObject *tmp_type, *tmp_value, *tmp_tb;
174 174
175 if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; " 175 if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
176 "use except clauses", 1) < 0) 176 "use except clauses", 1) < 0)
177 return NULL; 177 return NULL;
178 178
179 tstate = PyThreadState_GET(); 179 tstate = PyThreadState_GET();
180 tmp_type = tstate->exc_type; 180 tmp_type = tstate->exc_type;
181 tmp_value = tstate->exc_value; 181 tmp_value = tstate->exc_value;
182 tmp_tb = tstate->exc_traceback; 182 tmp_tb = tstate->exc_traceback;
183 tstate->exc_type = NULL; 183 tstate->exc_type = NULL;
184 tstate->exc_value = NULL; 184 tstate->exc_value = NULL;
185 tstate->exc_traceback = NULL; 185 tstate->exc_traceback = NULL;
186 Py_XDECREF(tmp_type); 186 Py_XDECREF(tmp_type);
187 Py_XDECREF(tmp_value); 187 Py_XDECREF(tmp_value);
188 Py_XDECREF(tmp_tb); 188 Py_XDECREF(tmp_tb);
189 /* For b/w compatibility */ 189 /* For b/w compatibility */
190 PySys_SetObject("exc_type", Py_None); 190 PySys_SetObject("exc_type", Py_None);
191 PySys_SetObject("exc_value", Py_None); 191 PySys_SetObject("exc_value", Py_None);
192 PySys_SetObject("exc_traceback", Py_None); 192 PySys_SetObject("exc_traceback", Py_None);
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(exc_clear_doc, 197 PyDoc_STRVAR(exc_clear_doc,
198 "exc_clear() -> None\n\ 198 "exc_clear() -> None\n\
199 \n\ 199 \n\
204 ); 204 );
205 205
206 static PyObject * 206 static PyObject *
207 sys_exit(PyObject *self, PyObject *args) 207 sys_exit(PyObject *self, PyObject *args)
208 { 208 {
209 PyObject *exit_code = 0; 209 PyObject *exit_code = 0;
210 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code)) 210 if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
211 return NULL; 211 return NULL;
212 /* Raise SystemExit so callers may catch it or clean up. */ 212 /* Raise SystemExit so callers may catch it or clean up. */
213 PyErr_SetObject(PyExc_SystemExit, exit_code); 213 PyErr_SetObject(PyExc_SystemExit, exit_code);
214 return NULL; 214 return NULL;
215 } 215 }
216 216
217 PyDoc_STRVAR(exit_doc, 217 PyDoc_STRVAR(exit_doc,
218 "exit([status])\n\ 218 "exit([status])\n\
219 \n\ 219 \n\
227 #ifdef Py_USING_UNICODE 227 #ifdef Py_USING_UNICODE
228 228
229 static PyObject * 229 static PyObject *
230 sys_getdefaultencoding(PyObject *self) 230 sys_getdefaultencoding(PyObject *self)
231 { 231 {
232 return PyString_FromString(PyUnicode_GetDefaultEncoding()); 232 return PyString_FromString(PyUnicode_GetDefaultEncoding());
233 } 233 }
234 234
235 PyDoc_STRVAR(getdefaultencoding_doc, 235 PyDoc_STRVAR(getdefaultencoding_doc,
236 "getdefaultencoding() -> string\n\ 236 "getdefaultencoding() -> string\n\
237 \n\ 237 \n\
240 ); 240 );
241 241
242 static PyObject * 242 static PyObject *
243 sys_setdefaultencoding(PyObject *self, PyObject *args) 243 sys_setdefaultencoding(PyObject *self, PyObject *args)
244 { 244 {
245 char *encoding; 245 char *encoding;
246 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding)) 246 if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
247 return NULL; 247 return NULL;
248 if (PyUnicode_SetDefaultEncoding(encoding)) 248 if (PyUnicode_SetDefaultEncoding(encoding))
249 return NULL; 249 return NULL;
250 Py_INCREF(Py_None); 250 Py_INCREF(Py_None);
251 return Py_None; 251 return Py_None;
252 } 252 }
253 253
254 PyDoc_STRVAR(setdefaultencoding_doc, 254 PyDoc_STRVAR(setdefaultencoding_doc,
255 "setdefaultencoding(encoding)\n\ 255 "setdefaultencoding(encoding)\n\
256 \n\ 256 \n\
258 ); 258 );
259 259
260 static PyObject * 260 static PyObject *
261 sys_getfilesystemencoding(PyObject *self) 261 sys_getfilesystemencoding(PyObject *self)
262 { 262 {
263 if (Py_FileSystemDefaultEncoding) 263 if (Py_FileSystemDefaultEncoding)
264 return PyString_FromString(Py_FileSystemDefaultEncoding); 264 return PyString_FromString(Py_FileSystemDefaultEncoding);
265 Py_INCREF(Py_None); 265 Py_INCREF(Py_None);
266 return Py_None; 266 return Py_None;
267 } 267 }
268 268
269 PyDoc_STRVAR(getfilesystemencoding_doc, 269 PyDoc_STRVAR(getfilesystemencoding_doc,
270 "getfilesystemencoding() -> string\n\ 270 "getfilesystemencoding() -> string\n\
271 \n\ 271 \n\
282 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL}; 282 static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
283 283
284 static int 284 static int
285 trace_init(void) 285 trace_init(void)
286 { 286 {
287 static char *whatnames[7] = {"call", "exception", "line", "return", 287 static char *whatnames[7] = {"call", "exception", "line", "return",
288 "c_call", "c_exception", "c_return"}; 288 "c_call", "c_exception", "c_return"};
289 PyObject *name; 289 PyObject *name;
290 int i; 290 int i;
291 for (i = 0; i < 7; ++i) { 291 for (i = 0; i < 7; ++i) {
292 if (whatstrings[i] == NULL) { 292 if (whatstrings[i] == NULL) {
293 name = PyString_InternFromString(whatnames[i]); 293 name = PyString_InternFromString(whatnames[i]);
294 if (name == NULL) 294 if (name == NULL)
295 return -1; 295 return -1;
296 whatstrings[i] = name; 296 whatstrings[i] = name;
297 } 297 }
298 } 298 }
299 return 0; 299 return 0;
300 } 300 }
301 301
302 302
303 static PyObject * 303 static PyObject *
304 call_trampoline(PyThreadState *tstate, PyObject* callback, 304 call_trampoline(PyThreadState *tstate, PyObject* callback,
305 PyFrameObject *frame, int what, PyObject *arg) 305 PyFrameObject *frame, int what, PyObject *arg)
306 { 306 {
307 PyObject *args = PyTuple_New(3); 307 PyObject *args = PyTuple_New(3);
308 PyObject *whatstr; 308 PyObject *whatstr;
309 PyObject *result; 309 PyObject *result;
310 310
311 if (args == NULL) 311 if (args == NULL)
312 return NULL; 312 return NULL;
313 Py_INCREF(frame); 313 Py_INCREF(frame);
314 whatstr = whatstrings[what]; 314 whatstr = whatstrings[what];
315 Py_INCREF(whatstr); 315 Py_INCREF(whatstr);
316 if (arg == NULL) 316 if (arg == NULL)
317 arg = Py_None; 317 arg = Py_None;
318 Py_INCREF(arg); 318 Py_INCREF(arg);
319 PyTuple_SET_ITEM(args, 0, (PyObject *)frame); 319 PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
320 PyTuple_SET_ITEM(args, 1, whatstr); 320 PyTuple_SET_ITEM(args, 1, whatstr);
321 PyTuple_SET_ITEM(args, 2, arg); 321 PyTuple_SET_ITEM(args, 2, arg);
322 322
323 /* call the Python-level function */ 323 /* call the Python-level function */
324 PyFrame_FastToLocals(frame); 324 PyFrame_FastToLocals(frame);
325 result = PyEval_CallObject(callback, args); 325 result = PyEval_CallObject(callback, args);
326 PyFrame_LocalsToFast(frame, 1); 326 PyFrame_LocalsToFast(frame, 1);
327 if (result == NULL) 327 if (result == NULL)
328 PyTraceBack_Here(frame); 328 PyTraceBack_Here(frame);
329 329
330 /* cleanup */ 330 /* cleanup */
331 Py_DECREF(args); 331 Py_DECREF(args);
332 return result; 332 return result;
333 } 333 }
334 334
335 static int 335 static int
336 profile_trampoline(PyObject *self, PyFrameObject *frame, 336 profile_trampoline(PyObject *self, PyFrameObject *frame,
337 int what, PyObject *arg) 337 int what, PyObject *arg)
338 { 338 {
339 PyThreadState *tstate = frame->f_tstate; 339 PyThreadState *tstate = frame->f_tstate;
340 PyObject *result; 340 PyObject *result;
341 341
342 if (arg == NULL) 342 if (arg == NULL)
343 arg = Py_None; 343 arg = Py_None;
344 result = call_trampoline(tstate, self, frame, what, arg); 344 result = call_trampoline(tstate, self, frame, what, arg);
345 if (result == NULL) { 345 if (result == NULL) {
346 PyEval_SetProfile(NULL, NULL); 346 PyEval_SetProfile(NULL, NULL);
347 return -1; 347 return -1;
348 } 348 }
349 Py_DECREF(result); 349 Py_DECREF(result);
350 return 0; 350 return 0;
351 } 351 }
352 352
353 static int 353 static int
354 trace_trampoline(PyObject *self, PyFrameObject *frame, 354 trace_trampoline(PyObject *self, PyFrameObject *frame,
355 int what, PyObject *arg) 355 int what, PyObject *arg)
356 { 356 {
357 PyThreadState *tstate = frame->f_tstate; 357 PyThreadState *tstate = frame->f_tstate;
358 PyObject *callback; 358 PyObject *callback;
359 PyObject *result; 359 PyObject *result;
360 360
361 if (what == PyTrace_CALL) 361 if (what == PyTrace_CALL)
362 callback = self; 362 callback = self;
363 else 363 else
364 callback = frame->f_trace; 364 callback = frame->f_trace;
365 if (callback == NULL) 365 if (callback == NULL)
366 return 0; 366 return 0;
367 result = call_trampoline(tstate, callback, frame, what, arg); 367 result = call_trampoline(tstate, callback, frame, what, arg);
368 if (result == NULL) { 368 if (result == NULL) {
369 PyEval_SetTrace(NULL, NULL); 369 PyEval_SetTrace(NULL, NULL);
370 Py_XDECREF(frame->f_trace); 370 Py_XDECREF(frame->f_trace);
371 frame->f_trace = NULL; 371 frame->f_trace = NULL;
372 return -1; 372 return -1;
373 } 373 }
374 if (result != Py_None) { 374 if (result != Py_None) {
375 PyObject *temp = frame->f_trace; 375 PyObject *temp = frame->f_trace;
376 frame->f_trace = NULL; 376 frame->f_trace = NULL;
377 Py_XDECREF(temp); 377 Py_XDECREF(temp);
378 frame->f_trace = result; 378 frame->f_trace = result;
379 } 379 }
380 else { 380 else {
381 Py_DECREF(result); 381 Py_DECREF(result);
382 } 382 }
383 return 0; 383 return 0;
384 } 384 }
385 385
386 static PyObject * 386 static PyObject *
387 sys_settrace(PyObject *self, PyObject *args) 387 sys_settrace(PyObject *self, PyObject *args)
388 { 388 {
389 if (trace_init() == -1) 389 if (trace_init() == -1)
390 return NULL; 390 return NULL;
391 if (args == Py_None) 391 if (args == Py_None)
392 PyEval_SetTrace(NULL, NULL); 392 PyEval_SetTrace(NULL, NULL);
393 else 393 else
394 PyEval_SetTrace(trace_trampoline, args); 394 PyEval_SetTrace(trace_trampoline, args);
395 Py_INCREF(Py_None); 395 Py_INCREF(Py_None);
396 return Py_None; 396 return Py_None;
397 } 397 }
398 398
399 PyDoc_STRVAR(settrace_doc, 399 PyDoc_STRVAR(settrace_doc,
400 "settrace(function)\n\ 400 "settrace(function)\n\
401 \n\ 401 \n\
404 ); 404 );
405 405
406 static PyObject * 406 static PyObject *
407 sys_gettrace(PyObject *self, PyObject *args) 407 sys_gettrace(PyObject *self, PyObject *args)
408 { 408 {
409 PyThreadState *tstate = PyThreadState_GET(); 409 PyThreadState *tstate = PyThreadState_GET();
410 PyObject *temp = tstate->c_traceobj; 410 PyObject *temp = tstate->c_traceobj;
411 411
412 if (temp == NULL) 412 if (temp == NULL)
413 temp = Py_None; 413 temp = Py_None;
414 Py_INCREF(temp); 414 Py_INCREF(temp);
415 return temp; 415 return temp;
416 } 416 }
417 417
418 PyDoc_STRVAR(gettrace_doc, 418 PyDoc_STRVAR(gettrace_doc,
419 "gettrace()\n\ 419 "gettrace()\n\
420 \n\ 420 \n\
423 ); 423 );
424 424
425 static PyObject * 425 static PyObject *
426 sys_setprofile(PyObject *self, PyObject *args) 426 sys_setprofile(PyObject *self, PyObject *args)
427 { 427 {
428 if (trace_init() == -1) 428 if (trace_init() == -1)
429 return NULL; 429 return NULL;
430 if (args == Py_None) 430 if (args == Py_None)
431 PyEval_SetProfile(NULL, NULL); 431 PyEval_SetProfile(NULL, NULL);
432 else 432 else
433 PyEval_SetProfile(profile_trampoline, args); 433 PyEval_SetProfile(profile_trampoline, args);
434 Py_INCREF(Py_None); 434 Py_INCREF(Py_None);
435 return Py_None; 435 return Py_None;
436 } 436 }
437 437
438 PyDoc_STRVAR(setprofile_doc, 438 PyDoc_STRVAR(setprofile_doc,
439 "setprofile(function)\n\ 439 "setprofile(function)\n\
440 \n\ 440 \n\
443 ); 443 );
444 444
445 static PyObject * 445 static PyObject *
446 sys_getprofile(PyObject *self, PyObject *args) 446 sys_getprofile(PyObject *self, PyObject *args)
447 { 447 {
448 PyThreadState *tstate = PyThreadState_GET(); 448 PyThreadState *tstate = PyThreadState_GET();
449 PyObject *temp = tstate->c_profileobj; 449 PyObject *temp = tstate->c_profileobj;
450 450
451 if (temp == NULL) 451 if (temp == NULL)
452 temp = Py_None; 452 temp = Py_None;
453 Py_INCREF(temp); 453 Py_INCREF(temp);
454 return temp; 454 return temp;
455 } 455 }
456 456
457 PyDoc_STRVAR(getprofile_doc, 457 PyDoc_STRVAR(getprofile_doc,
458 "getprofile()\n\ 458 "getprofile()\n\
459 \n\ 459 \n\
462 ); 462 );
463 463
464 static PyObject * 464 static PyObject *
465 sys_setcheckinterval(PyObject *self, PyObject *args) 465 sys_setcheckinterval(PyObject *self, PyObject *args)
466 { 466 {
467 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval)) 467 if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
468 return NULL; 468 return NULL;
469 Py_INCREF(Py_None); 469 Py_INCREF(Py_None);
470 return Py_None; 470 return Py_None;
471 } 471 }
472 472
473 PyDoc_STRVAR(setcheckinterval_doc, 473 PyDoc_STRVAR(setcheckinterval_doc,
474 "setcheckinterval(n)\n\ 474 "setcheckinterval(n)\n\
475 \n\ 475 \n\
478 ); 478 );
479 479
480 static PyObject * 480 static PyObject *
481 sys_getcheckinterval(PyObject *self, PyObject *args) 481 sys_getcheckinterval(PyObject *self, PyObject *args)
482 { 482 {
483 return PyInt_FromLong(_Py_CheckInterval); 483 return PyInt_FromLong(_Py_CheckInterval);
484 } 484 }
485 485
486 PyDoc_STRVAR(getcheckinterval_doc, 486 PyDoc_STRVAR(getcheckinterval_doc,
487 "getcheckinterval() -> current check interval; see setcheckinterval()." 487 "getcheckinterval() -> current check interval; see setcheckinterval()."
488 ); 488 );
489 489
490 #ifdef WITH_TSC 490 #ifdef WITH_TSC
491 static PyObject * 491 static PyObject *
492 sys_settscdump(PyObject *self, PyObject *args) 492 sys_settscdump(PyObject *self, PyObject *args)
493 { 493 {
494 int bool; 494 int bool;
495 PyThreadState *tstate = PyThreadState_Get(); 495 PyThreadState *tstate = PyThreadState_Get();
496 496
497 if (!PyArg_ParseTuple(args, "i:settscdump", &bool)) 497 if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
498 return NULL; 498 return NULL;
499 if (bool) 499 if (bool)
500 tstate->interp->tscdump = 1; 500 tstate->interp->tscdump = 1;
501 else 501 else
502 tstate->interp->tscdump = 0; 502 tstate->interp->tscdump = 0;
503 Py_INCREF(Py_None); 503 Py_INCREF(Py_None);
504 return Py_None; 504 return Py_None;
505 505
506 } 506 }
507 507
508 PyDoc_STRVAR(settscdump_doc, 508 PyDoc_STRVAR(settscdump_doc,
509 "settscdump(bool)\n\ 509 "settscdump(bool)\n\
515 #endif /* TSC */ 515 #endif /* TSC */
516 516
517 static PyObject * 517 static PyObject *
518 sys_setrecursionlimit(PyObject *self, PyObject *args) 518 sys_setrecursionlimit(PyObject *self, PyObject *args)
519 { 519 {
520 int new_limit; 520 int new_limit;
521 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit)) 521 if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
522 return NULL; 522 return NULL;
523 if (new_limit <= 0) { 523 if (new_limit <= 0) {
524 PyErr_SetString(PyExc_ValueError, 524 PyErr_SetString(PyExc_ValueError,
525 "recursion limit must be positive"); 525 "recursion limit must be positive");
526 return NULL; 526 return NULL;
527 } 527 }
528 Py_SetRecursionLimit(new_limit); 528 Py_SetRecursionLimit(new_limit);
529 Py_INCREF(Py_None); 529 Py_INCREF(Py_None);
530 return Py_None; 530 return Py_None;
531 } 531 }
532 532
533 PyDoc_STRVAR(setrecursionlimit_doc, 533 PyDoc_STRVAR(setrecursionlimit_doc,
534 "setrecursionlimit(n)\n\ 534 "setrecursionlimit(n)\n\
535 \n\ 535 \n\
540 ); 540 );
541 541
542 static PyObject * 542 static PyObject *
543 sys_getrecursionlimit(PyObject *self) 543 sys_getrecursionlimit(PyObject *self)
544 { 544 {
545 return PyInt_FromLong(Py_GetRecursionLimit()); 545 return PyInt_FromLong(Py_GetRecursionLimit());
546 } 546 }
547 547
548 PyDoc_STRVAR(getrecursionlimit_doc, 548 PyDoc_STRVAR(getrecursionlimit_doc,
549 "getrecursionlimit()\n\ 549 "getrecursionlimit()\n\
550 \n\ 550 \n\
565 ); 565 );
566 566
567 static PyObject * 567 static PyObject *
568 sys_getwindowsversion(PyObject *self) 568 sys_getwindowsversion(PyObject *self)
569 { 569 {
570 OSVERSIONINFO ver; 570 OSVERSIONINFO ver;
571 ver.dwOSVersionInfoSize = sizeof(ver); 571 ver.dwOSVersionInfoSize = sizeof(ver);
572 if (!GetVersionEx(&ver)) 572 if (!GetVersionEx(&ver))
573 return PyErr_SetFromWindowsErr(0); 573 return PyErr_SetFromWindowsErr(0);
574 return Py_BuildValue("HHHHs", 574 return Py_BuildValue("HHHHs",
575 ver.dwMajorVersion, 575 ver.dwMajorVersion,
576 ver.dwMinorVersion, 576 ver.dwMinorVersion,
577 ver.dwBuildNumber, 577 ver.dwBuildNumber,
578 ver.dwPlatformId, 578 ver.dwPlatformId,
579 ver.szCSDVersion); 579 ver.szCSDVersion);
580 } 580 }
581 581
582 #endif /* MS_WINDOWS */ 582 #endif /* MS_WINDOWS */
583 583
584 #ifdef HAVE_DLOPEN 584 #ifdef HAVE_DLOPEN
585 static PyObject * 585 static PyObject *
586 sys_setdlopenflags(PyObject *self, PyObject *args) 586 sys_setdlopenflags(PyObject *self, PyObject *args)
587 { 587 {
588 int new_val; 588 int new_val;
589 PyThreadState *tstate = PyThreadState_GET(); 589 PyThreadState *tstate = PyThreadState_GET();
590 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val)) 590 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
591 return NULL; 591 return NULL;
592 if (!tstate) 592 if (!tstate)
593 return NULL; 593 return NULL;
594 tstate->interp->dlopenflags = new_val; 594 tstate->interp->dlopenflags = new_val;
595 Py_INCREF(Py_None); 595 Py_INCREF(Py_None);
596 return Py_None; 596 return Py_None;
597 } 597 }
598 598
599 PyDoc_STRVAR(setdlopenflags_doc, 599 PyDoc_STRVAR(setdlopenflags_doc,
600 "setdlopenflags(n) -> None\n\ 600 "setdlopenflags(n) -> None\n\
601 \n\ 601 \n\
607 ); 607 );
608 608
609 static PyObject * 609 static PyObject *
610 sys_getdlopenflags(PyObject *self, PyObject *args) 610 sys_getdlopenflags(PyObject *self, PyObject *args)
611 { 611 {
612 PyThreadState *tstate = PyThreadState_GET(); 612 PyThreadState *tstate = PyThreadState_GET();
613 if (!tstate) 613 if (!tstate)
614 return NULL; 614 return NULL;
615 return PyInt_FromLong(tstate->interp->dlopenflags); 615 return PyInt_FromLong(tstate->interp->dlopenflags);
616 } 616 }
617 617
618 PyDoc_STRVAR(getdlopenflags_doc, 618 PyDoc_STRVAR(getdlopenflags_doc,
619 "getdlopenflags() -> int\n\ 619 "getdlopenflags() -> int\n\
620 \n\ 620 \n\
628 #include <malloc.h> 628 #include <malloc.h>
629 629
630 static PyObject * 630 static PyObject *
631 sys_mdebug(PyObject *self, PyObject *args) 631 sys_mdebug(PyObject *self, PyObject *args)
632 { 632 {
633 int flag; 633 int flag;
634 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 634 if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
635 return NULL; 635 return NULL;
636 mallopt(M_DEBUG, flag); 636 mallopt(M_DEBUG, flag);
637 Py_INCREF(Py_None); 637 Py_INCREF(Py_None);
638 return Py_None; 638 return Py_None;
639 } 639 }
640 #endif /* USE_MALLOPT */ 640 #endif /* USE_MALLOPT */
641 641
642 static PyObject * 642 static PyObject *
643 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds) 643 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
644 { 644 {
645 PyObject *res = NULL; 645 PyObject *res = NULL;
646 static PyObject *str__sizeof__, *gc_head_size = NULL; 646 static PyObject *str__sizeof__, *gc_head_size = NULL;
647 static char *kwlist[] = {"object", "default", 0}; 647 static char *kwlist[] = {"object", "default", 0};
648 PyObject *o, *dflt = NULL; 648 PyObject *o, *dflt = NULL;
649 649
650 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", 650 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
651 kwlist, &o, &dflt)) 651 kwlist, &o, &dflt))
652 return NULL; 652 return NULL;
653 653
654 /* Initialize static variable needed by _PyType_Lookup */ 654 /* Initialize static variable needed by _PyType_Lookup */
655 if (str__sizeof__ == NULL) { 655 if (str__sizeof__ == NULL) {
656 str__sizeof__ = PyString_InternFromString("__sizeof__"); 656 str__sizeof__ = PyString_InternFromString("__sizeof__");
657 if (str__sizeof__ == NULL) 657 if (str__sizeof__ == NULL)
658 return NULL; 658 return NULL;
659 } 659 }
660 660
661 /* Initialize static variable for GC head size */ 661 /* Initialize static variable for GC head size */
662 if (gc_head_size == NULL) { 662 if (gc_head_size == NULL) {
663 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head)); 663 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
664 if (gc_head_size == NULL) 664 if (gc_head_size == NULL)
665 return NULL; 665 return NULL;
666 } 666 }
667 667
668 /* Make sure the type is initialized. float gets initialized late */ 668 /* Make sure the type is initialized. float gets initialized late */
669 if (PyType_Ready(Py_TYPE(o)) < 0) 669 if (PyType_Ready(Py_TYPE(o)) < 0)
670 return NULL; 670 return NULL;
671 671
672 /* Instance of old-style class */ 672 /* Instance of old-style class */
673 if (PyInstance_Check(o)) 673 if (PyInstance_Check(o))
674 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize); 674 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
675 /* all other objects */ 675 /* all other objects */
676 else { 676 else {
677 PyObject *method = _PyType_Lookup(Py_TYPE(o), 677 PyObject *method = _PyType_Lookup(Py_TYPE(o),
678 str__sizeof__); 678 str__sizeof__);
679 if (method == NULL) 679 if (method == NULL)
680 PyErr_Format(PyExc_TypeError, 680 PyErr_Format(PyExc_TypeError,
681 "Type %.100s doesn't define __sizeof__", 681 "Type %.100s doesn't define __sizeof__",
682 Py_TYPE(o)->tp_name); 682 Py_TYPE(o)->tp_name);
683 else 683 else
684 res = PyObject_CallFunctionObjArgs(method, o, NULL); 684 res = PyObject_CallFunctionObjArgs(method, o, NULL);
685 } 685 }
686 686
687 /* Has a default value been given? */ 687 /* Has a default value been given? */
688 if ((res == NULL) && (dflt != NULL) && 688 if ((res == NULL) && (dflt != NULL) &&
689 PyErr_ExceptionMatches(PyExc_TypeError)) 689 PyErr_ExceptionMatches(PyExc_TypeError))
690 { 690 {
691 PyErr_Clear(); 691 PyErr_Clear();
692 Py_INCREF(dflt); 692 Py_INCREF(dflt);
693 return dflt; 693 return dflt;
694 } 694 }
695 else if (res == NULL) 695 else if (res == NULL)
696 return res; 696 return res;
697 697
698 /* add gc_head size */ 698 /* add gc_head size */
699 if (PyObject_IS_GC(o)) { 699 if (PyObject_IS_GC(o)) {
700 PyObject *tmp = res; 700 PyObject *tmp = res;
701 res = PyNumber_Add(tmp, gc_head_size); 701 res = PyNumber_Add(tmp, gc_head_size);
702 Py_DECREF(tmp); 702 Py_DECREF(tmp);
703 } 703 }
704 return res; 704 return res;
705 } 705 }
706 706
707 PyDoc_STRVAR(getsizeof_doc, 707 PyDoc_STRVAR(getsizeof_doc,
708 "getsizeof(object, default) -> int\n\ 708 "getsizeof(object, default) -> int\n\
709 \n\ 709 \n\
710 Return the size of object in bytes."); 710 Return the size of object in bytes.");
711 711
712 static PyObject * 712 static PyObject *
713 sys_getrefcount(PyObject *self, PyObject *arg) 713 sys_getrefcount(PyObject *self, PyObject *arg)
714 { 714 {
715 return PyInt_FromSsize_t(arg->ob_refcnt); 715 return PyInt_FromSsize_t(arg->ob_refcnt);
716 } 716 }
717 717
718 #ifdef Py_REF_DEBUG 718 #ifdef Py_REF_DEBUG
719 static PyObject * 719 static PyObject *
720 sys_gettotalrefcount(PyObject *self) 720 sys_gettotalrefcount(PyObject *self)
721 { 721 {
722 return PyInt_FromSsize_t(_Py_GetRefTotal()); 722 return PyInt_FromSsize_t(_Py_GetRefTotal());
723 } 723 }
724 #endif /* Py_REF_DEBUG */ 724 #endif /* Py_REF_DEBUG */
725 725
726 PyDoc_STRVAR(getrefcount_doc, 726 PyDoc_STRVAR(getrefcount_doc,
727 "getrefcount(object) -> integer\n\ 727 "getrefcount(object) -> integer\n\
733 733
734 #ifdef COUNT_ALLOCS 734 #ifdef COUNT_ALLOCS
735 static PyObject * 735 static PyObject *
736 sys_getcounts(PyObject *self) 736 sys_getcounts(PyObject *self)
737 { 737 {
738 extern PyObject *get_counts(void); 738 extern PyObject *get_counts(void);
739 739
740 return get_counts(); 740 return get_counts();
741 } 741 }
742 #endif 742 #endif
743 743
744 PyDoc_STRVAR(getframe_doc, 744 PyDoc_STRVAR(getframe_doc,
745 "_getframe([depth]) -> frameobject\n\ 745 "_getframe([depth]) -> frameobject\n\
754 ); 754 );
755 755
756 static PyObject * 756 static PyObject *
757 sys_getframe(PyObject *self, PyObject *args) 757 sys_getframe(PyObject *self, PyObject *args)
758 { 758 {
759 PyFrameObject *f = PyThreadState_GET()->frame; 759 PyFrameObject *f = PyThreadState_GET()->frame;
760 int depth = -1; 760 int depth = -1;
761 761
762 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 762 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
763 return NULL; 763 return NULL;
764 764
765 while (depth > 0 && f != NULL) { 765 while (depth > 0 && f != NULL) {
766 f = f->f_back; 766 f = f->f_back;
767 --depth; 767 --depth;
768 } 768 }
769 if (f == NULL) { 769 if (f == NULL) {
770 PyErr_SetString(PyExc_ValueError, 770 PyErr_SetString(PyExc_ValueError,
771 "call stack is not deep enough"); 771 "call stack is not deep enough");
772 return NULL; 772 return NULL;
773 } 773 }
774 Py_INCREF(f); 774 Py_INCREF(f);
775 return (PyObject*)f; 775 return (PyObject*)f;
776 } 776 }
777 777
778 PyDoc_STRVAR(current_frames_doc, 778 PyDoc_STRVAR(current_frames_doc,
779 "_current_frames() -> dictionary\n\ 779 "_current_frames() -> dictionary\n\
780 \n\ 780 \n\
785 ); 785 );
786 786
787 static PyObject * 787 static PyObject *
788 sys_current_frames(PyObject *self, PyObject *noargs) 788 sys_current_frames(PyObject *self, PyObject *noargs)
789 { 789 {
790 return _PyThread_CurrentFrames(); 790 return _PyThread_CurrentFrames();
791 } 791 }
792 792
793 PyDoc_STRVAR(call_tracing_doc, 793 PyDoc_STRVAR(call_tracing_doc,
794 "call_tracing(func, args) -> object\n\ 794 "call_tracing(func, args) -> object\n\
795 \n\ 795 \n\
799 ); 799 );
800 800
801 static PyObject * 801 static PyObject *
802 sys_call_tracing(PyObject *self, PyObject *args) 802 sys_call_tracing(PyObject *self, PyObject *args)
803 { 803 {
804 PyObject *func, *funcargs; 804 PyObject *func, *funcargs;
805 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs)) 805 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
806 return NULL; 806 return NULL;
807 return _PyEval_CallTracing(func, funcargs); 807 return _PyEval_CallTracing(func, funcargs);
808 } 808 }
809 809
810 PyDoc_STRVAR(callstats_doc, 810 PyDoc_STRVAR(callstats_doc,
811 "callstats() -> tuple of integers\n\ 811 "callstats() -> tuple of integers\n\
812 \n\ 812 \n\
849 #endif 849 #endif
850 850
851 static PyObject * 851 static PyObject *
852 sys_clear_type_cache(PyObject* self, PyObject* args) 852 sys_clear_type_cache(PyObject* self, PyObject* args)
853 { 853 {
854 PyType_ClearCache(); 854 PyType_ClearCache();
855 Py_RETURN_NONE; 855 Py_RETURN_NONE;
856 } 856 }
857 857
858 PyDoc_STRVAR(sys_clear_type_cache__doc__, 858 PyDoc_STRVAR(sys_clear_type_cache__doc__,
859 "_clear_type_cache() -> None\n\ 859 "_clear_type_cache() -> None\n\
860 Clear the internal type lookup cache."); 860 Clear the internal type lookup cache.");
861 861
862 862
863 static PyMethodDef sys_methods[] = { 863 static PyMethodDef sys_methods[] = {
864 /* Might as well keep this in alphabetic order */ 864 /* Might as well keep this in alphabetic order */
865 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS, 865 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
866 callstats_doc}, 866 callstats_doc},
867 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS, 867 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
868 sys_clear_type_cache__doc__}, 868 sys_clear_type_cache__doc__},
869 {"_current_frames", sys_current_frames, METH_NOARGS, 869 {"_current_frames", sys_current_frames, METH_NOARGS,
870 current_frames_doc}, 870 current_frames_doc},
871 {"displayhook", sys_displayhook, METH_O, displayhook_doc}, 871 {"displayhook", sys_displayhook, METH_O, displayhook_doc},
872 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc}, 872 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
873 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc}, 873 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},
874 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, 874 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
875 {"exit", sys_exit, METH_VARARGS, exit_doc}, 875 {"exit", sys_exit, METH_VARARGS, exit_doc},
876 #ifdef Py_USING_UNICODE 876 #ifdef Py_USING_UNICODE
877 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, 877 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
878 METH_NOARGS, getdefaultencoding_doc}, 878 METH_NOARGS, getdefaultencoding_doc},
879 #endif 879 #endif
880 #ifdef HAVE_DLOPEN 880 #ifdef HAVE_DLOPEN
881 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, 881 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
882 getdlopenflags_doc}, 882 getdlopenflags_doc},
883 #endif 883 #endif
884 #ifdef COUNT_ALLOCS 884 #ifdef COUNT_ALLOCS
885 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS}, 885 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
886 #endif 886 #endif
887 #ifdef DYNAMIC_EXECUTION_PROFILE 887 #ifdef DYNAMIC_EXECUTION_PROFILE
888 {"getdxp", _Py_GetDXProfile, METH_VARARGS}, 888 {"getdxp", _Py_GetDXProfile, METH_VARARGS},
889 #endif 889 #endif
890 #ifdef Py_USING_UNICODE 890 #ifdef Py_USING_UNICODE
891 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, 891 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
892 METH_NOARGS, getfilesystemencoding_doc}, 892 METH_NOARGS, getfilesystemencoding_doc},
893 #endif 893 #endif
894 #ifdef Py_TRACE_REFS 894 #ifdef Py_TRACE_REFS
895 {"getobjects", _Py_GetObjects, METH_VARARGS}, 895 {"getobjects", _Py_GetObjects, METH_VARARGS},
896 #endif 896 #endif
897 #ifdef Py_REF_DEBUG 897 #ifdef Py_REF_DEBUG
898 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS}, 898 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
899 #endif 899 #endif
900 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, 900 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
901 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, 901 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
902 getrecursionlimit_doc}, 902 getrecursionlimit_doc},
903 {"getsizeof", (PyCFunction)sys_getsizeof, 903 {"getsizeof", (PyCFunction)sys_getsizeof,
904 METH_VARARGS | METH_KEYWORDS, getsizeof_doc}, 904 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
905 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, 905 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
906 #ifdef MS_WINDOWS 906 #ifdef MS_WINDOWS
907 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, 907 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
908 getwindowsversion_doc}, 908 getwindowsversion_doc},
909 #endif /* MS_WINDOWS */ 909 #endif /* MS_WINDOWS */
910 #ifdef USE_MALLOPT 910 #ifdef USE_MALLOPT
911 {"mdebug", sys_mdebug, METH_VARARGS}, 911 {"mdebug", sys_mdebug, METH_VARARGS},
912 #endif 912 #endif
913 #ifdef Py_USING_UNICODE 913 #ifdef Py_USING_UNICODE
914 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, 914 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
915 setdefaultencoding_doc}, 915 setdefaultencoding_doc},
916 #endif 916 #endif
917 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, 917 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
918 setcheckinterval_doc}, 918 setcheckinterval_doc},
919 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS, 919 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
920 getcheckinterval_doc}, 920 getcheckinterval_doc},
921 #ifdef HAVE_DLOPEN 921 #ifdef HAVE_DLOPEN
922 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS, 922 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
923 setdlopenflags_doc}, 923 setdlopenflags_doc},
924 #endif 924 #endif
925 {"setprofile", sys_setprofile, METH_O, setprofile_doc}, 925 {"setprofile", sys_setprofile, METH_O, setprofile_doc},
926 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc}, 926 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
927 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS, 927 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
928 setrecursionlimit_doc}, 928 setrecursionlimit_doc},
929 #ifdef WITH_TSC 929 #ifdef WITH_TSC
930 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc}, 930 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
931 #endif 931 #endif
932 {"settrace", sys_settrace, METH_O, settrace_doc}, 932 {"settrace", sys_settrace, METH_O, settrace_doc},
933 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc}, 933 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
934 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, 934 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
935 {NULL, NULL} /* sentinel */ 935 {NULL, NULL} /* sentinel */
936 }; 936 };
937 937
938 static PyObject * 938 static PyObject *
939 list_builtin_module_names(void) 939 list_builtin_module_names(void)
940 { 940 {
941 PyObject *list = PyList_New(0); 941 PyObject *list = PyList_New(0);
942 int i; 942 int i;
943 if (list == NULL) 943 if (list == NULL)
944 return NULL; 944 return NULL;
945 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 945 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
946 PyObject *name = PyString_FromString( 946 PyObject *name = PyString_FromString(
947 PyImport_Inittab[i].name); 947 PyImport_Inittab[i].name);
948 if (name == NULL) 948 if (name == NULL)
949 break; 949 break;
950 PyList_Append(list, name); 950 PyList_Append(list, name);
951 Py_DECREF(name); 951 Py_DECREF(name);
952 } 952 }
953 if (PyList_Sort(list) != 0) { 953 if (PyList_Sort(list) != 0) {
954 Py_DECREF(list); 954 Py_DECREF(list);
955 list = NULL; 955 list = NULL;
956 } 956 }
957 if (list) { 957 if (list) {
958 PyObject *v = PyList_AsTuple(list); 958 PyObject *v = PyList_AsTuple(list);
959 Py_DECREF(list); 959 Py_DECREF(list);
960 list = v; 960 list = v;
961 } 961 }
962 return list; 962 return list;
963 } 963 }
964 964
965 static PyObject *warnoptions = NULL; 965 static PyObject *warnoptions = NULL;
966 966
967 void 967 void
968 PySys_ResetWarnOptions(void) 968 PySys_ResetWarnOptions(void)
969 { 969 {
970 if (warnoptions == NULL || !PyList_Check(warnoptions)) 970 if (warnoptions == NULL || !PyList_Check(warnoptions))
971 return; 971 return;
972 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 972 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
973 } 973 }
974 974
975 void 975 void
976 PySys_AddWarnOption(char *s) 976 PySys_AddWarnOption(char *s)
977 { 977 {
978 PyObject *str; 978 PyObject *str;
979 979
980 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 980 if (warnoptions == NULL || !PyList_Check(warnoptions)) {
981 Py_XDECREF(warnoptions); 981 Py_XDECREF(warnoptions);
982 warnoptions = PyList_New(0); 982 warnoptions = PyList_New(0);
983 if (warnoptions == NULL) 983 if (warnoptions == NULL)
984 return; 984 return;
985 } 985 }
986 str = PyString_FromString(s); 986 str = PyString_FromString(s);
987 if (str != NULL) { 987 if (str != NULL) {
988 PyList_Append(warnoptions, str); 988 PyList_Append(warnoptions, str);
989 Py_DECREF(str); 989 Py_DECREF(str);
990 } 990 }
991 } 991 }
992 992
993 int 993 int
994 PySys_HasWarnOptions(void) 994 PySys_HasWarnOptions(void)
995 { 995 {
1111 static const char *svn_revision; 1111 static const char *svn_revision;
1112 1112
1113 static void 1113 static void
1114 svnversion_init(void) 1114 svnversion_init(void)
1115 { 1115 {
1116 const char *python, *br_start, *br_end, *br_end2, *svnversion; 1116 const char *python, *br_start, *br_end, *br_end2, *svnversion;
1117 Py_ssize_t len; 1117 Py_ssize_t len;
1118 int istag; 1118 int istag;
1119 1119
1120 if (svn_initialized) 1120 if (svn_initialized)
1121 return; 1121 return;
1122 1122
1123 python = strstr(headurl, "/python/"); 1123 python = strstr(headurl, "/python/");
1124 if (!python) { 1124 if (!python) {
1125 /* XXX quick hack to get bzr working */ 1125 /* XXX quick hack to get bzr working */
1126 *patchlevel_revision = '\0'; 1126 *patchlevel_revision = '\0';
1127 strcpy(branch, ""); 1127 strcpy(branch, "");
1128 strcpy(shortbranch, "unknown"); 1128 strcpy(shortbranch, "unknown");
1129 svn_revision = ""; 1129 svn_revision = "";
1130 return; 1130 return;
1131 /* Py_FatalError("subversion keywords missing"); */ 1131 /* Py_FatalError("subversion keywords missing"); */
1132 } 1132 }
1133 1133
1134 br_start = python + 8; 1134 br_start = python + 8;
1135 br_end = strchr(br_start, '/'); 1135 br_end = strchr(br_start, '/');
1136 assert(br_end); 1136 assert(br_end);
1137 1137
1138 /* Works even for trunk, 1138 /* Works even for trunk,
1139 as we are in trunk/Python/sysmodule.c */ 1139 as we are in trunk/Python/sysmodule.c */
1140 br_end2 = strchr(br_end+1, '/'); 1140 br_end2 = strchr(br_end+1, '/');
1141 1141
1142 istag = strncmp(br_start, "tags", 4) == 0; 1142 istag = strncmp(br_start, "tags", 4) == 0;
1143 if (strncmp(br_start, "trunk", 5) == 0) { 1143 if (strncmp(br_start, "trunk", 5) == 0) {
1144 strcpy(branch, "trunk"); 1144 strcpy(branch, "trunk");
1145 strcpy(shortbranch, "trunk"); 1145 strcpy(shortbranch, "trunk");
1146 1146
1147 } 1147 }
1148 else if (istag || strncmp(br_start, "branches", 8) == 0) { 1148 else if (istag || strncmp(br_start, "branches", 8) == 0) {
1149 len = br_end2 - br_start; 1149 len = br_end2 - br_start;
1150 strncpy(branch, br_start, len); 1150 strncpy(branch, br_start, len);
1151 branch[len] = '\0'; 1151 branch[len] = '\0';
1152 1152
1153 len = br_end2 - (br_end + 1); 1153 len = br_end2 - (br_end + 1);
1154 strncpy(shortbranch, br_end + 1, len); 1154 strncpy(shortbranch, br_end + 1, len);
1155 shortbranch[len] = '\0'; 1155 shortbranch[len] = '\0';
1156 } 1156 }
1157 else { 1157 else {
1158 Py_FatalError("bad HeadURL"); 1158 Py_FatalError("bad HeadURL");
1159 return; 1159 return;
1160 } 1160 }
1161 1161
1162 1162
1163 svnversion = _Py_svnversion(); 1163 svnversion = _Py_svnversion();
1164 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0) 1164 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
1165 svn_revision = svnversion; 1165 svn_revision = svnversion;
1166 else if (istag) { 1166 else if (istag) {
1167 len = strlen(_patchlevel_revision); 1167 len = strlen(_patchlevel_revision);
1168 assert(len >= 13); 1168 assert(len >= 13);
1169 assert(len < (sizeof(patchlevel_revision) + 13)); 1169 assert(len < (sizeof(patchlevel_revision) + 13));
1170 strncpy(patchlevel_revision, _patchlevel_revision + 11, 1170 strncpy(patchlevel_revision, _patchlevel_revision + 11,
1171 len - 13); 1171 len - 13);
1172 patchlevel_revision[len - 13] = '\0'; 1172 patchlevel_revision[len - 13] = '\0';
1173 svn_revision = patchlevel_revision; 1173 svn_revision = patchlevel_revision;
1174 } 1174 }
1175 else 1175 else
1176 svn_revision = ""; 1176 svn_revision = "";
1177 1177
1178 svn_initialized = 1; 1178 svn_initialized = 1;
1179 } 1179 }
1180 1180
1181 /* Return svnversion output if available. 1181 /* Return svnversion output if available.
1182 Else return Revision of patchlevel.h if on branch. 1182 Else return Revision of patchlevel.h if on branch.
1183 Else return empty string */ 1183 Else return empty string */
1184 const char* 1184 const char*
1185 Py_SubversionRevision() 1185 Py_SubversionRevision()
1186 { 1186 {
1187 svnversion_init(); 1187 svnversion_init();
1188 return svn_revision; 1188 return svn_revision;
1189 } 1189 }
1190 1190
1191 const char* 1191 const char*
1192 Py_SubversionShortBranch() 1192 Py_SubversionShortBranch()
1193 { 1193 {
1194 svnversion_init(); 1194 svnversion_init();
1195 return shortbranch; 1195 return shortbranch;
1196 } 1196 }
1197 1197
1198 1198
1199 PyDoc_STRVAR(flags__doc__, 1199 PyDoc_STRVAR(flags__doc__,
1200 "sys.flags\n\ 1200 "sys.flags\n\
1202 Flags provided through command line arguments or environment vars."); 1202 Flags provided through command line arguments or environment vars.");
1203 1203
1204 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0}; 1204 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1205 1205
1206 static PyStructSequence_Field flags_fields[] = { 1206 static PyStructSequence_Field flags_fields[] = {
1207 {"debug", "-d"}, 1207 {"debug", "-d"},
1208 {"py3k_warning", "-3"}, 1208 {"py3k_warning", "-3"},
1209 {"division_warning", "-Q"}, 1209 {"division_warning", "-Q"},
1210 {"division_new", "-Qnew"}, 1210 {"division_new", "-Qnew"},
1211 {"inspect", "-i"}, 1211 {"inspect", "-i"},
1212 {"interactive", "-i"}, 1212 {"interactive", "-i"},
1213 {"optimize", "-O or -OO"}, 1213 {"optimize", "-O or -OO"},
1214 {"dont_write_bytecode", "-B"}, 1214 {"dont_write_bytecode", "-B"},
1215 {"no_user_site", "-s"}, 1215 {"no_user_site", "-s"},
1216 {"no_site", "-S"}, 1216 {"no_site", "-S"},
1217 {"ignore_environment", "-E"}, 1217 {"ignore_environment", "-E"},
1218 {"tabcheck", "-t or -tt"}, 1218 {"tabcheck", "-t or -tt"},
1219 {"verbose", "-v"}, 1219 {"verbose", "-v"},
1220 #ifdef RISCOS 1220 #ifdef RISCOS
1221 {"riscos_wimp", "???"}, 1221 {"riscos_wimp", "???"},
1222 #endif 1222 #endif
1223 /* {"unbuffered", "-u"}, */ 1223 /* {"unbuffered", "-u"}, */
1224 {"unicode", "-U"}, 1224 {"unicode", "-U"},
1225 /* {"skip_first", "-x"}, */ 1225 /* {"skip_first", "-x"}, */
1226 {"bytes_warning", "-b"}, 1226 {"bytes_warning", "-b"},
1227 {0} 1227 {0}
1228 }; 1228 };
1229 1229
1230 static PyStructSequence_Desc flags_desc = { 1230 static PyStructSequence_Desc flags_desc = {
1231 "sys.flags", /* name */ 1231 "sys.flags", /* name */
1232 flags__doc__, /* doc */ 1232 flags__doc__, /* doc */
1233 flags_fields, /* fields */ 1233 flags_fields, /* fields */
1234 #ifdef RISCOS 1234 #ifdef RISCOS
1235 16 1235 16
1236 #else 1236 #else
1237 15 1237 15
1238 #endif 1238 #endif
1239 }; 1239 };
1240 1240
1241 static PyObject* 1241 static PyObject*
1242 make_flags(void) 1242 make_flags(void)
1243 { 1243 {
1244 int pos = 0; 1244 int pos = 0;
1245 PyObject *seq; 1245 PyObject *seq;
1246 1246
1247 seq = PyStructSequence_New(&FlagsType); 1247 seq = PyStructSequence_New(&FlagsType);
1248 if (seq == NULL) 1248 if (seq == NULL)
1249 return NULL; 1249 return NULL;
1250 1250
1251 #define SetFlag(flag) \ 1251 #define SetFlag(flag) \
1252 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag)) 1252 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1253 1253
1254 SetFlag(Py_DebugFlag); 1254 SetFlag(Py_DebugFlag);
1255 SetFlag(Py_Py3kWarningFlag); 1255 SetFlag(Py_Py3kWarningFlag);
1256 SetFlag(Py_DivisionWarningFlag); 1256 SetFlag(Py_DivisionWarningFlag);
1257 SetFlag(_Py_QnewFlag); 1257 SetFlag(_Py_QnewFlag);
1258 SetFlag(Py_InspectFlag); 1258 SetFlag(Py_InspectFlag);
1259 SetFlag(Py_InteractiveFlag); 1259 SetFlag(Py_InteractiveFlag);
1260 SetFlag(Py_OptimizeFlag); 1260 SetFlag(Py_OptimizeFlag);
1261 SetFlag(Py_DontWriteBytecodeFlag); 1261 SetFlag(Py_DontWriteBytecodeFlag);
1262 SetFlag(Py_NoUserSiteDirectory); 1262 SetFlag(Py_NoUserSiteDirectory);
1263 SetFlag(Py_NoSiteFlag); 1263 SetFlag(Py_NoSiteFlag);
1264 SetFlag(Py_IgnoreEnvironmentFlag); 1264 SetFlag(Py_IgnoreEnvironmentFlag);
1265 SetFlag(Py_TabcheckFlag); 1265 SetFlag(Py_TabcheckFlag);
1266 SetFlag(Py_VerboseFlag); 1266 SetFlag(Py_VerboseFlag);
1267 #ifdef RISCOS 1267 #ifdef RISCOS
1268 SetFlag(Py_RISCOSWimpFlag); 1268 SetFlag(Py_RISCOSWimpFlag);
1269 #endif 1269 #endif
1270 /* SetFlag(saw_unbuffered_flag); */ 1270 /* SetFlag(saw_unbuffered_flag); */
1271 SetFlag(Py_UnicodeFlag); 1271 SetFlag(Py_UnicodeFlag);
1272 /* SetFlag(skipfirstline); */ 1272 /* SetFlag(skipfirstline); */
1273 SetFlag(Py_BytesWarningFlag); 1273 SetFlag(Py_BytesWarningFlag);
1274 #undef SetFlag 1274 #undef SetFlag
1275 1275
1276 if (PyErr_Occurred()) { 1276 if (PyErr_Occurred()) {
1277 return NULL; 1277 return NULL;
1278 } 1278 }
1279 return seq; 1279 return seq;
1280 } 1280 }
1281 1281
1282 PyObject * 1282 PyObject *
1283 _PySys_Init(void) 1283 _PySys_Init(void)
1284 { 1284 {
1285 PyObject *m, *v, *sysdict; 1285 PyObject *m, *v, *sysdict;
1286 PyObject *sysin, *sysout, *syserr; 1286 PyObject *sysin, *sysout, *syserr;
1287 char *s; 1287 char *s;
1288 1288
1289 m = Py_InitModule3("sys", sys_methods, sys_doc); 1289 m = Py_InitModule3("sys", sys_methods, sys_doc);
1290 if (m == NULL) 1290 if (m == NULL)
1291 return NULL; 1291 return NULL;
1292 sysdict = PyModule_GetDict(m); 1292 sysdict = PyModule_GetDict(m);
1293 #define SET_SYS_FROM_STRING(key, value) \ 1293 #define SET_SYS_FROM_STRING(key, value) \
1294 v = value; \ 1294 v = value; \
1295 if (v != NULL) \ 1295 if (v != NULL) \
1296 PyDict_SetItemString(sysdict, key, v); \ 1296 PyDict_SetItemString(sysdict, key, v); \
1297 Py_XDECREF(v) 1297 Py_XDECREF(v)
1298 1298
1299 /* Check that stdin is not a directory 1299 /* Check that stdin is not a directory
1300 Using shell redirection, you can redirect stdin to a directory, 1300 Using shell redirection, you can redirect stdin to a directory,
1301 crashing the Python interpreter. Catch this common mistake here 1301 crashing the Python interpreter. Catch this common mistake here
1302 and output a useful error message. Note that under MS Windows, 1302 and output a useful error message. Note that under MS Windows,
1303 the shell already prevents that. */ 1303 the shell already prevents that. */
1304 #if !defined(MS_WINDOWS) 1304 #if !defined(MS_WINDOWS)
1305 { 1305 {
1306 struct stat sb; 1306 struct stat sb;
1307 if (fstat(fileno(stdin), &sb) == 0 && 1307 if (fstat(fileno(stdin), &sb) == 0 &&
1308 S_ISDIR(sb.st_mode)) { 1308 S_ISDIR(sb.st_mode)) {
1309 /* There's nothing more we can do. */ 1309 /* There's nothing more we can do. */
1310 /* Py_FatalError() will core dump, so just exit. */ 1310 /* Py_FatalError() will core dump, so just exit. */
1311 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1311 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1312 exit(EXIT_FAILURE); 1312 exit(EXIT_FAILURE);
1313 } 1313 }
1314 } 1314 }
1315 #endif 1315 #endif
1316 1316
1317 /* Closing the standard FILE* if sys.std* goes aways causes problems 1317 /* Closing the standard FILE* if sys.std* goes aways causes problems
1318 * for embedded Python usages. Closing them when somebody explicitly 1318 * for embedded Python usages. Closing them when somebody explicitly
1319 * invokes .close() might be possible, but the FAQ promises they get 1319 * invokes .close() might be possible, but the FAQ promises they get
1320 * never closed. However, we still need to get write errors when 1320 * never closed. However, we still need to get write errors when
1321 * writing fails (e.g. because stdout is redirected), so we flush the 1321 * writing fails (e.g. because stdout is redirected), so we flush the
1322 * streams and check for errors before the file objects are deleted. 1322 * streams and check for errors before the file objects are deleted.
1323 * On OS X, fflush()ing stdin causes an error, so we exempt stdin 1323 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1324 * from that procedure. 1324 * from that procedure.
1325 */ 1325 */
1326 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL); 1326 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1327 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush); 1327 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1328 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush); 1328 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1329 if (PyErr_Occurred()) 1329 if (PyErr_Occurred())
1330 return NULL; 1330 return NULL;
1331 1331
1332 PyDict_SetItemString(sysdict, "stdin", sysin); 1332 PyDict_SetItemString(sysdict, "stdin", sysin);
1333 PyDict_SetItemString(sysdict, "stdout", sysout); 1333 PyDict_SetItemString(sysdict, "stdout", sysout);
1334 PyDict_SetItemString(sysdict, "stderr", syserr); 1334 PyDict_SetItemString(sysdict, "stderr", syserr);
1335 /* Make backup copies for cleanup */ 1335 /* Make backup copies for cleanup */
1336 PyDict_SetItemString(sysdict, "__stdin__", sysin); 1336 PyDict_SetItemString(sysdict, "__stdin__", sysin);
1337 PyDict_SetItemString(sysdict, "__stdout__", sysout); 1337 PyDict_SetItemString(sysdict, "__stdout__", sysout);
1338 PyDict_SetItemString(sysdict, "__stderr__", syserr); 1338 PyDict_SetItemString(sysdict, "__stderr__", syserr);
1339 PyDict_SetItemString(sysdict, "__displayhook__", 1339 PyDict_SetItemString(sysdict, "__displayhook__",
1340 PyDict_GetItemString(sysdict, "displayhook")); 1340 PyDict_GetItemString(sysdict, "displayhook"));
1341 PyDict_SetItemString(sysdict, "__excepthook__", 1341 PyDict_SetItemString(sysdict, "__excepthook__",
1342 PyDict_GetItemString(sysdict, "excepthook")); 1342 PyDict_GetItemString(sysdict, "excepthook"));
1343 Py_XDECREF(sysin); 1343 Py_XDECREF(sysin);
1344 Py_XDECREF(sysout); 1344 Py_XDECREF(sysout);
1345 Py_XDECREF(syserr); 1345 Py_XDECREF(syserr);
1346 1346
1347 SET_SYS_FROM_STRING("version", 1347 SET_SYS_FROM_STRING("version",
1348 PyString_FromString(Py_GetVersion())); 1348 PyString_FromString(Py_GetVersion()));
1349 SET_SYS_FROM_STRING("hexversion", 1349 SET_SYS_FROM_STRING("hexversion",
1350 PyInt_FromLong(PY_VERSION_HEX)); 1350 PyInt_FromLong(PY_VERSION_HEX));
1351 svnversion_init(); 1351 svnversion_init();
1352 SET_SYS_FROM_STRING("subversion", 1352 SET_SYS_FROM_STRING("subversion",
1353 Py_BuildValue("(ssz)", "CPython", branch, 1353 Py_BuildValue("(ssz)", "CPython", branch,
1354 svn_revision)); 1354 svn_revision));
1355 SET_SYS_FROM_STRING("dont_write_bytecode", 1355 SET_SYS_FROM_STRING("dont_write_bytecode",
1356 PyBool_FromLong(Py_DontWriteBytecodeFlag)); 1356 PyBool_FromLong(Py_DontWriteBytecodeFlag));
1357 /* 1357 /*
1358 * These release level checks are mutually exclusive and cover 1358 * These release level checks are mutually exclusive and cover
1359 * the field, so don't get too fancy with the pre-processor! 1359 * the field, so don't get too fancy with the pre-processor!
1360 */ 1360 */
1361 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1361 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1362 s = "alpha"; 1362 s = "alpha";
1363 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1363 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1364 s = "beta"; 1364 s = "beta";
1365 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1365 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1366 s = "candidate"; 1366 s = "candidate";
1367 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1367 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1368 s = "final"; 1368 s = "final";
1369 #endif 1369 #endif
1370 1370
1371 SET_SYS_FROM_STRING("version_info", 1371 SET_SYS_FROM_STRING("version_info",
1372 Py_BuildValue("iiisi", PY_MAJOR_VERSION, 1372 Py_BuildValue("iiisi", PY_MAJOR_VERSION,
1373 PY_MINOR_VERSION, 1373 PY_MINOR_VERSION,
1374 PY_MICRO_VERSION, s, 1374 PY_MICRO_VERSION, s,
1375 PY_RELEASE_SERIAL)); 1375 PY_RELEASE_SERIAL));
1376 SET_SYS_FROM_STRING("api_version", 1376 SET_SYS_FROM_STRING("api_version",
1377 PyInt_FromLong(PYTHON_API_VERSION)); 1377 PyInt_FromLong(PYTHON_API_VERSION));
1378 SET_SYS_FROM_STRING("copyright", 1378 SET_SYS_FROM_STRING("copyright",
1379 PyString_FromString(Py_GetCopyright())); 1379 PyString_FromString(Py_GetCopyright()));
1380 SET_SYS_FROM_STRING("platform", 1380 SET_SYS_FROM_STRING("platform",
1381 PyString_FromString(Py_GetPlatform())); 1381 PyString_FromString(Py_GetPlatform()));
1382 SET_SYS_FROM_STRING("executable", 1382 SET_SYS_FROM_STRING("executable",
1383 PyString_FromString(Py_GetProgramFullPath())); 1383 PyString_FromString(Py_GetProgramFullPath()));
1384 SET_SYS_FROM_STRING("prefix", 1384 SET_SYS_FROM_STRING("prefix",
1385 PyString_FromString(Py_GetPrefix())); 1385 PyString_FromString(Py_GetPrefix()));
1386 SET_SYS_FROM_STRING("exec_prefix", 1386 SET_SYS_FROM_STRING("exec_prefix",
1387 PyString_FromString(Py_GetExecPrefix())); 1387 PyString_FromString(Py_GetExecPrefix()));
1388 SET_SYS_FROM_STRING("maxsize", 1388 SET_SYS_FROM_STRING("maxsize",
1389 PyInt_FromSsize_t(PY_SSIZE_T_MAX)); 1389 PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1390 SET_SYS_FROM_STRING("maxint", 1390 SET_SYS_FROM_STRING("maxint",
1391 PyInt_FromLong(PyInt_GetMax())); 1391 PyInt_FromLong(PyInt_GetMax()));
1392 SET_SYS_FROM_STRING("py3kwarning", 1392 SET_SYS_FROM_STRING("py3kwarning",
1393 PyBool_FromLong(Py_Py3kWarningFlag)); 1393 PyBool_FromLong(Py_Py3kWarningFlag));
1394 SET_SYS_FROM_STRING("float_info", 1394 SET_SYS_FROM_STRING("float_info",
1395 PyFloat_GetInfo()); 1395 PyFloat_GetInfo());
1396 #ifdef Py_USING_UNICODE 1396 #ifdef Py_USING_UNICODE
1397 SET_SYS_FROM_STRING("maxunicode", 1397 SET_SYS_FROM_STRING("maxunicode",
1398 PyInt_FromLong(PyUnicode_GetMax())); 1398 PyInt_FromLong(PyUnicode_GetMax()));
1399 #endif 1399 #endif
1400 SET_SYS_FROM_STRING("builtin_module_names", 1400 SET_SYS_FROM_STRING("builtin_module_names",
1401 list_builtin_module_names()); 1401 list_builtin_module_names());
1402 { 1402 {
1403 /* Assumes that longs are at least 2 bytes long. 1403 /* Assumes that longs are at least 2 bytes long.
1404 Should be safe! */ 1404 Should be safe! */
1405 unsigned long number = 1; 1405 unsigned long number = 1;
1406 char *value; 1406 char *value;
1407 1407
1408 s = (char *) &number; 1408 s = (char *) &number;
1409 if (s[0] == 0) 1409 if (s[0] == 0)
1410 value = "big"; 1410 value = "big";
1411 else 1411 else
1412 value = "little"; 1412 value = "little";
1413 SET_SYS_FROM_STRING("byteorder", 1413 SET_SYS_FROM_STRING("byteorder",
1414 PyString_FromString(value)); 1414 PyString_FromString(value));
1415 } 1415 }
1416 #ifdef MS_COREDLL 1416 #ifdef MS_COREDLL
1417 SET_SYS_FROM_STRING("dllhandle", 1417 SET_SYS_FROM_STRING("dllhandle",
1418 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1418 PyLong_FromVoidPtr(PyWin_DLLhModule));
1419 SET_SYS_FROM_STRING("winver", 1419 SET_SYS_FROM_STRING("winver",
1420 PyString_FromString(PyWin_DLLVersionString)); 1420 PyString_FromString(PyWin_DLLVersionString));
1421 #endif 1421 #endif
1422 if (warnoptions == NULL) { 1422 if (warnoptions == NULL) {
1423 warnoptions = PyList_New(0); 1423 warnoptions = PyList_New(0);
1424 } 1424 }
1425 else { 1425 else {
1426 Py_INCREF(warnoptions); 1426 Py_INCREF(warnoptions);
1427 } 1427 }
1428 if (warnoptions != NULL) { 1428 if (warnoptions != NULL) {
1429 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1429 PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1430 } 1430 }
1431 1431
1432 if (FlagsType.tp_name == 0) 1432 if (FlagsType.tp_name == 0)
1433 PyStructSequence_InitType(&FlagsType, &flags_desc); 1433 PyStructSequence_InitType(&FlagsType, &flags_desc);
1434 SET_SYS_FROM_STRING("flags", make_flags()); 1434 SET_SYS_FROM_STRING("flags", make_flags());
1435 /* prevent user from creating new instances */ 1435 /* prevent user from creating new instances */
1436 FlagsType.tp_init = NULL; 1436 FlagsType.tp_init = NULL;
1437 FlagsType.tp_new = NULL; 1437 FlagsType.tp_new = NULL;
1438 1438
1439 #undef SET_SYS_FROM_STRING 1439 #undef SET_SYS_FROM_STRING
1440 if (PyErr_Occurred()) 1440 if (PyErr_Occurred())
1441 return NULL; 1441 return NULL;
1442 return m; 1442 return m;
1443 } 1443 }
1444 1444
1445 static PyObject * 1445 static PyObject *
1446 makepathobject(char *path, int delim) 1446 makepathobject(char *path, int delim)
1447 { 1447 {
1448 int i, n; 1448 int i, n;
1449 char *p; 1449 char *p;
1450 PyObject *v, *w; 1450 PyObject *v, *w;
1451 1451
1452 n = 1; 1452 n = 1;
1453 p = path; 1453 p = path;
1454 while ((p = strchr(p, delim)) != NULL) { 1454 while ((p = strchr(p, delim)) != NULL) {
1455 n++; 1455 n++;
1456 p++; 1456 p++;
1457 } 1457 }
1458 v = PyList_New(n); 1458 v = PyList_New(n);
1459 if (v == NULL) 1459 if (v == NULL)
1460 return NULL; 1460 return NULL;
1461 for (i = 0; ; i++) { 1461 for (i = 0; ; i++) {
1462 p = strchr(path, delim); 1462 p = strchr(path, delim);
1463 if (p == NULL) 1463 if (p == NULL)
1464 p = strchr(path, '\0'); /* End of string */ 1464 p = strchr(path, '\0'); /* End of string */
1465 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path)); 1465 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1466 if (w == NULL) { 1466 if (w == NULL) {
1467 Py_DECREF(v); 1467 Py_DECREF(v);
1468 return NULL; 1468 return NULL;
1469 } 1469 }
1470 PyList_SetItem(v, i, w); 1470 PyList_SetItem(v, i, w);
1471 if (*p == '\0') 1471 if (*p == '\0')
1472 break; 1472 break;
1473 path = p+1; 1473 path = p+1;
1474 } 1474 }
1475 return v; 1475 return v;
1476 } 1476 }
1477 1477
1478 void 1478 void
1479 PySys_SetPath(char *path) 1479 PySys_SetPath(char *path)
1480 { 1480 {
1481 PyObject *v; 1481 PyObject *v;
1482 if ((v = makepathobject(path, DELIM)) == NULL) 1482 if ((v = makepathobject(path, DELIM)) == NULL)
1483 Py_FatalError("can't create sys.path"); 1483 Py_FatalError("can't create sys.path");
1484 if (PySys_SetObject("path", v) != 0) 1484 if (PySys_SetObject("path", v) != 0)
1485 Py_FatalError("can't assign sys.path"); 1485 Py_FatalError("can't assign sys.path");
1486 Py_DECREF(v); 1486 Py_DECREF(v);
1487 } 1487 }
1488 1488
1489 static PyObject * 1489 static PyObject *
1490 makeargvobject(int argc, char **argv) 1490 makeargvobject(int argc, char **argv)
1491 { 1491 {
1492 PyObject *av; 1492 PyObject *av;
1493 if (argc <= 0 || argv == NULL) { 1493 if (argc <= 0 || argv == NULL) {
1494 /* Ensure at least one (empty) argument is seen */ 1494 /* Ensure at least one (empty) argument is seen */
1495 static char *empty_argv[1] = {""}; 1495 static char *empty_argv[1] = {""};
1496 argv = empty_argv; 1496 argv = empty_argv;
1497 argc = 1; 1497 argc = 1;
1498 } 1498 }
1499 av = PyList_New(argc); 1499 av = PyList_New(argc);
1500 if (av != NULL) { 1500 if (av != NULL) {
1501 int i; 1501 int i;
1502 for (i = 0; i < argc; i++) { 1502 for (i = 0; i < argc; i++) {
1503 #ifdef __VMS 1503 #ifdef __VMS
1504 PyObject *v; 1504 PyObject *v;
1505 1505
1506 /* argv[0] is the script pathname if known */ 1506 /* argv[0] is the script pathname if known */
1507 if (i == 0) { 1507 if (i == 0) {
1508 char* fn = decc$translate_vms(argv[0]); 1508 char* fn = decc$translate_vms(argv[0]);
1509 if ((fn == (char *)0) || fn == (char *)-1) 1509 if ((fn == (char *)0) || fn == (char *)-1)
1510 v = PyString_FromString(argv[0]); 1510 v = PyString_FromString(argv[0]);
1511 else 1511 else
1512 v = PyString_FromString( 1512 v = PyString_FromString(
1513 decc$translate_vms(argv[0])); 1513 decc$translate_vms(argv[0]));
1514 } else 1514 } else
1515 v = PyString_FromString(argv[i]); 1515 v = PyString_FromString(argv[i]);
1516 #else 1516 #else
1517 PyObject *v = PyString_FromString(argv[i]); 1517 PyObject *v = PyString_FromString(argv[i]);
1518 #endif 1518 #endif
1519 if (v == NULL) { 1519 if (v == NULL) {
1520 Py_DECREF(av); 1520 Py_DECREF(av);
1521 av = NULL; 1521 av = NULL;
1522 break; 1522 break;
1523 } 1523 }
1524 PyList_SetItem(av, i, v); 1524 PyList_SetItem(av, i, v);
1525 } 1525 }
1526 } 1526 }
1527 return av; 1527 return av;
1528 } 1528 }
1529 1529
1530 void 1530 void
1531 PySys_SetArgv(int argc, char **argv) 1531 PySys_SetArgv(int argc, char **argv)
1532 { 1532 {
1533 #if defined(HAVE_REALPATH) 1533 #if defined(HAVE_REALPATH)
1534 char fullpath[MAXPATHLEN]; 1534 char fullpath[MAXPATHLEN];
1535 #elif defined(MS_WINDOWS) && !defined(MS_WINCE) 1535 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1536 char fullpath[MAX_PATH]; 1536 char fullpath[MAX_PATH];
1537 #endif 1537 #endif
1538 PyObject *av = makeargvobject(argc, argv); 1538 PyObject *av = makeargvobject(argc, argv);
1539 PyObject *path = PySys_GetObject("path"); 1539 PyObject *path = PySys_GetObject("path");
1540 if (av == NULL) 1540 if (av == NULL)
1541 Py_FatalError("no mem for sys.argv"); 1541 Py_FatalError("no mem for sys.argv");
1542 if (PySys_SetObject("argv", av) != 0) 1542 if (PySys_SetObject("argv", av) != 0)
1543 Py_FatalError("can't assign sys.argv"); 1543 Py_FatalError("can't assign sys.argv");
1544 if (path != NULL) { 1544 if (path != NULL) {
1545 char *argv0 = argv[0]; 1545 char *argv0 = argv[0];
1546 char *p = NULL; 1546 char *p = NULL;
1547 Py_ssize_t n = 0; 1547 Py_ssize_t n = 0;
1548 PyObject *a; 1548 PyObject *a;
1549 #ifdef HAVE_READLINK 1549 #ifdef HAVE_READLINK
1550 char link[MAXPATHLEN+1]; 1550 char link[MAXPATHLEN+1];
1551 char argv0copy[2*MAXPATHLEN+1]; 1551 char argv0copy[2*MAXPATHLEN+1];
1552 int nr = 0; 1552 int nr = 0;
1553 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) 1553 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1554 nr = readlink(argv0, link, MAXPATHLEN); 1554 nr = readlink(argv0, link, MAXPATHLEN);
1555 if (nr > 0) { 1555 if (nr > 0) {
1556 /* It's a symlink */ 1556 /* It's a symlink */
1557 link[nr] = '\0'; 1557 link[nr] = '\0';
1558 if (link[0] == SEP) 1558 if (link[0] == SEP)
1559 argv0 = link; /* Link to absolute path */ 1559 argv0 = link; /* Link to absolute path */
1560 else if (strchr(link, SEP) == NULL) 1560 else if (strchr(link, SEP) == NULL)
1561 ; /* Link without path */ 1561 ; /* Link without path */
1562 else { 1562 else {
1563 /* Must join(dirname(argv0), link) */ 1563 /* Must join(dirname(argv0), link) */
1564 char *q = strrchr(argv0, SEP); 1564 char *q = strrchr(argv0, SEP);
1565 if (q == NULL) 1565 if (q == NULL)
1566 argv0 = link; /* argv0 without path */ 1566 argv0 = link; /* argv0 without path */
1567 else { 1567 else {
1568 /* Must make a copy */ 1568 /* Must make a copy */
1569 strcpy(argv0copy, argv0); 1569 strcpy(argv0copy, argv0);
1570 q = strrchr(argv0copy, SEP); 1570 q = strrchr(argv0copy, SEP);
1571 strcpy(q+1, link); 1571 strcpy(q+1, link);
1572 argv0 = argv0copy; 1572 argv0 = argv0copy;
1573 } 1573 }
1574 } 1574 }
1575 } 1575 }
1576 #endif /* HAVE_READLINK */ 1576 #endif /* HAVE_READLINK */
1577 #if SEP == '\\' /* Special case for MS filename syntax */ 1577 #if SEP == '\\' /* Special case for MS filename syntax */
1578 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1578 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1579 char *q; 1579 char *q;
1580 #if defined(MS_WINDOWS) && !defined(MS_WINCE) 1580 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1581 /* This code here replaces the first element in argv with the full 1581 /* This code here replaces the first element in argv with the full
1582 path that it represents. Under CE, there are no relative paths so 1582 path that it represents. Under CE, there are no relative paths so
1583 the argument must be the full path anyway. */ 1583 the argument must be the full path anyway. */
1584 char *ptemp; 1584 char *ptemp;
1585 if (GetFullPathName(argv0, 1585 if (GetFullPathName(argv0,
1586 sizeof(fullpath), 1586 sizeof(fullpath),
1587 fullpath, 1587 fullpath,
1588 &ptemp)) { 1588 &ptemp)) {
1589 argv0 = fullpath; 1589 argv0 = fullpath;
1590 } 1590 }
1591 #endif 1591 #endif
1592 p = strrchr(argv0, SEP); 1592 p = strrchr(argv0, SEP);
1593 /* Test for alternate separator */ 1593 /* Test for alternate separator */
1594 q = strrchr(p ? p : argv0, '/'); 1594 q = strrchr(p ? p : argv0, '/');
1595 if (q != NULL) 1595 if (q != NULL)
1596 p = q; 1596 p = q;
1597 if (p != NULL) { 1597 if (p != NULL) {
1598 n = p + 1 - argv0; 1598 n = p + 1 - argv0;
1599 if (n > 1 && p[-1] != ':') 1599 if (n > 1 && p[-1] != ':')
1600 n--; /* Drop trailing separator */ 1600 n--; /* Drop trailing separator */
1601 } 1601 }
1602 } 1602 }
1603 #else /* All other filename syntaxes */ 1603 #else /* All other filename syntaxes */
1604 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1604 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1605 #if defined(HAVE_REALPATH) 1605 #if defined(HAVE_REALPATH)
1606 if (realpath(argv0, fullpath)) { 1606 if (realpath(argv0, fullpath)) {
1607 argv0 = fullpath; 1607 argv0 = fullpath;
1608 } 1608 }
1609 #endif 1609 #endif
1610 p = strrchr(argv0, SEP); 1610 p = strrchr(argv0, SEP);
1611 } 1611 }
1612 if (p != NULL) { 1612 if (p != NULL) {
1613 #ifndef RISCOS 1613 #ifndef RISCOS
1614 n = p + 1 - argv0; 1614 n = p + 1 - argv0;
1615 #else /* don't include trailing separator */ 1615 #else /* don't include trailing separator */
1616 n = p - argv0; 1616 n = p - argv0;
1617 #endif /* RISCOS */ 1617 #endif /* RISCOS */
1618 #if SEP == '/' /* Special case for Unix filename syntax */ 1618 #if SEP == '/' /* Special case for Unix filename syntax */
1619 if (n > 1) 1619 if (n > 1)
1620 n--; /* Drop trailing separator */ 1620 n--; /* Drop trailing separator */
1621 #endif /* Unix */ 1621 #endif /* Unix */
1622 } 1622 }
1623 #endif /* All others */ 1623 #endif /* All others */
1624 a = PyString_FromStringAndSize(argv0, n); 1624 a = PyString_FromStringAndSize(argv0, n);
1625 if (a == NULL) 1625 if (a == NULL)
1626 Py_FatalError("no mem for sys.path insertion"); 1626 Py_FatalError("no mem for sys.path insertion");
1627 if (PyList_Insert(path, 0, a) < 0) 1627 if (PyList_Insert(path, 0, a) < 0)
1628 Py_FatalError("sys.path.insert(0) failed"); 1628 Py_FatalError("sys.path.insert(0) failed");
1629 Py_DECREF(a); 1629 Py_DECREF(a);
1630 } 1630 }
1631 Py_DECREF(av); 1631 Py_DECREF(av);
1632 } 1632 }
1633 1633
1634 1634
1635 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface. 1635 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1636 Adapted from code submitted by Just van Rossum. 1636 Adapted from code submitted by Just van Rossum.
1657 */ 1657 */
1658 1658
1659 static void 1659 static void
1660 mywrite(char *name, FILE *fp, const char *format, va_list va) 1660 mywrite(char *name, FILE *fp, const char *format, va_list va)
1661 { 1661 {
1662 PyObject *file; 1662 PyObject *file;
1663 PyObject *error_type, *error_value, *error_traceback; 1663 PyObject *error_type, *error_value, *error_traceback;
1664 1664
1665 PyErr_Fetch(&error_type, &error_value, &error_traceback); 1665 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1666 file = PySys_GetObject(name); 1666 file = PySys_GetObject(name);
1667 if (file == NULL || PyFile_AsFile(file) == fp) 1667 if (file == NULL || PyFile_AsFile(file) == fp)
1668 vfprintf(fp, format, va); 1668 vfprintf(fp, format, va);
1669 else { 1669 else {
1670 char buffer[1001]; 1670 char buffer[1001];
1671 const int written = PyOS_vsnprintf(buffer, sizeof(buffer), 1671 const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1672 format, va); 1672 format, va);
1673 if (PyFile_WriteString(buffer, file) != 0) { 1673 if (PyFile_WriteString(buffer, file) != 0) {
1674 PyErr_Clear(); 1674 PyErr_Clear();
1675 fputs(buffer, fp); 1675 fputs(buffer, fp);
1676 } 1676 }
1677 if (written < 0 || (size_t)written >= sizeof(buffer)) { 1677 if (written < 0 || (size_t)written >= sizeof(buffer)) {
1678 const char *truncated = "... truncated"; 1678 const char *truncated = "... truncated";
1679 if (PyFile_WriteString(truncated, file) != 0) { 1679 if (PyFile_WriteString(truncated, file) != 0) {
1680 PyErr_Clear(); 1680 PyErr_Clear();
1681 fputs(truncated, fp); 1681 fputs(truncated, fp);
1682 } 1682 }
1683 } 1683 }
1684 } 1684 }
1685 PyErr_Restore(error_type, error_value, error_traceback); 1685 PyErr_Restore(error_type, error_value, error_traceback);
1686 } 1686 }
1687 1687
1688 void 1688 void
1689 PySys_WriteStdout(const char *format, ...) 1689 PySys_WriteStdout(const char *format, ...)
1690 { 1690 {
1691 va_list va; 1691 va_list va;
1692 1692
1693 va_start(va, format); 1693 va_start(va, format);
1694 mywrite("stdout", stdout, format, va); 1694 mywrite("stdout", stdout, format, va);
1695 va_end(va); 1695 va_end(va);
1696 } 1696 }
1697 1697
1698 void 1698 void
1699 PySys_WriteStderr(const char *format, ...) 1699 PySys_WriteStderr(const char *format, ...)
1700 { 1700 {
1701 va_list va; 1701 va_list va;
1702 1702
1703 va_start(va, format); 1703 va_start(va, format);
1704 mywrite("stderr", stderr, format, va); 1704 mywrite("stderr", stderr, format, va);
1705 va_end(va); 1705 va_end(va);
1706 } 1706 }