Mercurial > cpython-lru_cache-weakref

comparison Python/sysmodule.c @ 61463:fd25030223b0 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Untabify C files. Will watch buildbots.
author Antoine Pitrou <solipsis@pitrou.net>
date Sun, 09 May 2010 14:46:46 +0000
parents b8750c72b9bc
children c2917ac5d526
comparison
equal deleted inserted replaced
61460:d698fb056a45 61463:fd25030223b0
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\
568 ); 568 );
569 569
570 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0}; 570 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
571 571
572 static PyStructSequence_Field windows_version_fields[] = { 572 static PyStructSequence_Field windows_version_fields[] = {
573 {"major", "Major version number"}, 573 {"major", "Major version number"},
574 {"minor", "Minor version number"}, 574 {"minor", "Minor version number"},
575 {"build", "Build number"}, 575 {"build", "Build number"},
576 {"platform", "Operating system platform"}, 576 {"platform", "Operating system platform"},
577 {"service_pack", "Latest Service Pack installed on the system"}, 577 {"service_pack", "Latest Service Pack installed on the system"},
578 {"service_pack_major", "Service Pack major version number"}, 578 {"service_pack_major", "Service Pack major version number"},
579 {"service_pack_minor", "Service Pack minor version number"}, 579 {"service_pack_minor", "Service Pack minor version number"},
580 {"suite_mask", "Bit mask identifying available product suites"}, 580 {"suite_mask", "Bit mask identifying available product suites"},
581 {"product_type", "System product type"}, 581 {"product_type", "System product type"},
582 {0} 582 {0}
583 }; 583 };
584 584
585 static PyStructSequence_Desc windows_version_desc = { 585 static PyStructSequence_Desc windows_version_desc = {
586 "sys.getwindowsversion", /* name */ 586 "sys.getwindowsversion", /* name */
587 getwindowsversion_doc, /* doc */ 587 getwindowsversion_doc, /* doc */
588 windows_version_fields, /* fields */ 588 windows_version_fields, /* fields */
589 5 /* For backward compatibility, 589 5 /* For backward compatibility,
590 only the first 5 items are accessible 590 only the first 5 items are accessible
591 via indexing, the rest are name only */ 591 via indexing, the rest are name only */
592 }; 592 };
593 593
594 static PyObject * 594 static PyObject *
595 sys_getwindowsversion(PyObject *self) 595 sys_getwindowsversion(PyObject *self)
596 { 596 {
597 PyObject *version; 597 PyObject *version;
598 int pos = 0; 598 int pos = 0;
599 OSVERSIONINFOEX ver; 599 OSVERSIONINFOEX ver;
600 ver.dwOSVersionInfoSize = sizeof(ver); 600 ver.dwOSVersionInfoSize = sizeof(ver);
601 if (!GetVersionEx((OSVERSIONINFO*) &ver)) 601 if (!GetVersionEx((OSVERSIONINFO*) &ver))
602 return PyErr_SetFromWindowsErr(0); 602 return PyErr_SetFromWindowsErr(0);
603 603
604 version = PyStructSequence_New(&WindowsVersionType); 604 version = PyStructSequence_New(&WindowsVersionType);
605 if (version == NULL) 605 if (version == NULL)
606 return NULL; 606 return NULL;
607 607
608 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion)); 608 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
609 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion)); 609 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
610 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber)); 610 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
611 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId)); 611 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
612 PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion)); 612 PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
613 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor)); 613 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
614 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor)); 614 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
615 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask)); 615 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
616 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType)); 616 PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
617 617
618 return version; 618 return version;
619 } 619 }
620 620
621 #endif /* MS_WINDOWS */ 621 #endif /* MS_WINDOWS */
622 622
623 #ifdef HAVE_DLOPEN 623 #ifdef HAVE_DLOPEN
624 static PyObject * 624 static PyObject *
625 sys_setdlopenflags(PyObject *self, PyObject *args) 625 sys_setdlopenflags(PyObject *self, PyObject *args)
626 { 626 {
627 int new_val; 627 int new_val;
628 PyThreadState *tstate = PyThreadState_GET(); 628 PyThreadState *tstate = PyThreadState_GET();
629 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val)) 629 if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
630 return NULL; 630 return NULL;
631 if (!tstate) 631 if (!tstate)
632 return NULL; 632 return NULL;
633 tstate->interp->dlopenflags = new_val; 633 tstate->interp->dlopenflags = new_val;
634 Py_INCREF(Py_None); 634 Py_INCREF(Py_None);
635 return Py_None; 635 return Py_None;
636 } 636 }
637 637
638 PyDoc_STRVAR(setdlopenflags_doc, 638 PyDoc_STRVAR(setdlopenflags_doc,
639 "setdlopenflags(n) -> None\n\ 639 "setdlopenflags(n) -> None\n\
640 \n\ 640 \n\
648 h2py script."); 648 h2py script.");
649 649
650 static PyObject * 650 static PyObject *
651 sys_getdlopenflags(PyObject *self, PyObject *args) 651 sys_getdlopenflags(PyObject *self, PyObject *args)
652 { 652 {
653 PyThreadState *tstate = PyThreadState_GET(); 653 PyThreadState *tstate = PyThreadState_GET();
654 if (!tstate) 654 if (!tstate)
655 return NULL; 655 return NULL;
656 return PyInt_FromLong(tstate->interp->dlopenflags); 656 return PyInt_FromLong(tstate->interp->dlopenflags);
657 } 657 }
658 658
659 PyDoc_STRVAR(getdlopenflags_doc, 659 PyDoc_STRVAR(getdlopenflags_doc,
660 "getdlopenflags() -> int\n\ 660 "getdlopenflags() -> int\n\
661 \n\ 661 \n\
662 Return the current value of the flags that are used for dlopen calls.\n\ 662 Return the current value of the flags that are used for dlopen calls.\n\
663 The flag constants are defined in the ctypes and DLFCN modules."); 663 The flag constants are defined in the ctypes and DLFCN modules.");
664 664
665 #endif /* HAVE_DLOPEN */ 665 #endif /* HAVE_DLOPEN */
666 666
667 #ifdef USE_MALLOPT 667 #ifdef USE_MALLOPT
668 /* Link with -lmalloc (or -lmpc) on an SGI */ 668 /* Link with -lmalloc (or -lmpc) on an SGI */
669 #include <malloc.h> 669 #include <malloc.h>
670 670
671 static PyObject * 671 static PyObject *
672 sys_mdebug(PyObject *self, PyObject *args) 672 sys_mdebug(PyObject *self, PyObject *args)
673 { 673 {
674 int flag; 674 int flag;
675 if (!PyArg_ParseTuple(args, "i:mdebug", &flag)) 675 if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
676 return NULL; 676 return NULL;
677 mallopt(M_DEBUG, flag); 677 mallopt(M_DEBUG, flag);
678 Py_INCREF(Py_None); 678 Py_INCREF(Py_None);
679 return Py_None; 679 return Py_None;
680 } 680 }
681 #endif /* USE_MALLOPT */ 681 #endif /* USE_MALLOPT */
682 682
683 static PyObject * 683 static PyObject *
684 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds) 684 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
685 { 685 {
686 PyObject *res = NULL; 686 PyObject *res = NULL;
687 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL; 687 static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL;
688 static char *kwlist[] = {"object", "default", 0}; 688 static char *kwlist[] = {"object", "default", 0};
689 PyObject *o, *dflt = NULL; 689 PyObject *o, *dflt = NULL;
690 690
691 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof", 691 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
692 kwlist, &o, &dflt)) 692 kwlist, &o, &dflt))
693 return NULL; 693 return NULL;
694 694
695 /* Initialize static variable for GC head size */ 695 /* Initialize static variable for GC head size */
696 if (gc_head_size == NULL) { 696 if (gc_head_size == NULL) {
697 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head)); 697 gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
698 if (gc_head_size == NULL) 698 if (gc_head_size == NULL)
699 return NULL; 699 return NULL;
700 } 700 }
701 701
702 /* Make sure the type is initialized. float gets initialized late */ 702 /* Make sure the type is initialized. float gets initialized late */
703 if (PyType_Ready(Py_TYPE(o)) < 0) 703 if (PyType_Ready(Py_TYPE(o)) < 0)
704 return NULL; 704 return NULL;
705 705
706 /* Instance of old-style class */ 706 /* Instance of old-style class */
707 if (PyInstance_Check(o)) 707 if (PyInstance_Check(o))
708 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize); 708 res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
709 /* all other objects */ 709 /* all other objects */
710 else { 710 else {
711 PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__", 711 PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
712 &str__sizeof__); 712 &str__sizeof__);
713 if (method == NULL) { 713 if (method == NULL) {
714 if (!PyErr_Occurred()) 714 if (!PyErr_Occurred())
715 PyErr_Format(PyExc_TypeError, 715 PyErr_Format(PyExc_TypeError,
716 "Type %.100s doesn't define __sizeof__", 716 "Type %.100s doesn't define __sizeof__",
717 Py_TYPE(o)->tp_name); 717 Py_TYPE(o)->tp_name);
718 } 718 }
719 else { 719 else {
720 res = PyObject_CallFunctionObjArgs(method, NULL); 720 res = PyObject_CallFunctionObjArgs(method, NULL);
721 Py_DECREF(method); 721 Py_DECREF(method);
722 } 722 }
723 } 723 }
724 724
725 /* Has a default value been given? */ 725 /* Has a default value been given? */
726 if ((res == NULL) && (dflt != NULL) && 726 if ((res == NULL) && (dflt != NULL) &&
727 PyErr_ExceptionMatches(PyExc_TypeError)) 727 PyErr_ExceptionMatches(PyExc_TypeError))
728 { 728 {
729 PyErr_Clear(); 729 PyErr_Clear();
730 Py_INCREF(dflt); 730 Py_INCREF(dflt);
731 return dflt; 731 return dflt;
732 } 732 }
733 else if (res == NULL) 733 else if (res == NULL)
734 return res; 734 return res;
735 735
736 /* add gc_head size */ 736 /* add gc_head size */
737 if (PyObject_IS_GC(o)) { 737 if (PyObject_IS_GC(o)) {
738 PyObject *tmp = res; 738 PyObject *tmp = res;
739 res = PyNumber_Add(tmp, gc_head_size); 739 res = PyNumber_Add(tmp, gc_head_size);
740 Py_DECREF(tmp); 740 Py_DECREF(tmp);
741 } 741 }
742 return res; 742 return res;
743 } 743 }
744 744
745 PyDoc_STRVAR(getsizeof_doc, 745 PyDoc_STRVAR(getsizeof_doc,
746 "getsizeof(object, default) -> int\n\ 746 "getsizeof(object, default) -> int\n\
747 \n\ 747 \n\
748 Return the size of object in bytes."); 748 Return the size of object in bytes.");
749 749
750 static PyObject * 750 static PyObject *
751 sys_getrefcount(PyObject *self, PyObject *arg) 751 sys_getrefcount(PyObject *self, PyObject *arg)
752 { 752 {
753 return PyInt_FromSsize_t(arg->ob_refcnt); 753 return PyInt_FromSsize_t(arg->ob_refcnt);
754 } 754 }
755 755
756 #ifdef Py_REF_DEBUG 756 #ifdef Py_REF_DEBUG
757 static PyObject * 757 static PyObject *
758 sys_gettotalrefcount(PyObject *self) 758 sys_gettotalrefcount(PyObject *self)
759 { 759 {
760 return PyInt_FromSsize_t(_Py_GetRefTotal()); 760 return PyInt_FromSsize_t(_Py_GetRefTotal());
761 } 761 }
762 #endif /* Py_REF_DEBUG */ 762 #endif /* Py_REF_DEBUG */
763 763
764 PyDoc_STRVAR(getrefcount_doc, 764 PyDoc_STRVAR(getrefcount_doc,
765 "getrefcount(object) -> integer\n\ 765 "getrefcount(object) -> integer\n\
771 771
772 #ifdef COUNT_ALLOCS 772 #ifdef COUNT_ALLOCS
773 static PyObject * 773 static PyObject *
774 sys_getcounts(PyObject *self) 774 sys_getcounts(PyObject *self)
775 { 775 {
776 extern PyObject *get_counts(void); 776 extern PyObject *get_counts(void);
777 777
778 return get_counts(); 778 return get_counts();
779 } 779 }
780 #endif 780 #endif
781 781
782 PyDoc_STRVAR(getframe_doc, 782 PyDoc_STRVAR(getframe_doc,
783 "_getframe([depth]) -> frameobject\n\ 783 "_getframe([depth]) -> frameobject\n\
792 ); 792 );
793 793
794 static PyObject * 794 static PyObject *
795 sys_getframe(PyObject *self, PyObject *args) 795 sys_getframe(PyObject *self, PyObject *args)
796 { 796 {
797 PyFrameObject *f = PyThreadState_GET()->frame; 797 PyFrameObject *f = PyThreadState_GET()->frame;
798 int depth = -1; 798 int depth = -1;
799 799
800 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) 800 if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
801 return NULL; 801 return NULL;
802 802
803 while (depth > 0 && f != NULL) { 803 while (depth > 0 && f != NULL) {
804 f = f->f_back; 804 f = f->f_back;
805 --depth; 805 --depth;
806 } 806 }
807 if (f == NULL) { 807 if (f == NULL) {
808 PyErr_SetString(PyExc_ValueError, 808 PyErr_SetString(PyExc_ValueError,
809 "call stack is not deep enough"); 809 "call stack is not deep enough");
810 return NULL; 810 return NULL;
811 } 811 }
812 Py_INCREF(f); 812 Py_INCREF(f);
813 return (PyObject*)f; 813 return (PyObject*)f;
814 } 814 }
815 815
816 PyDoc_STRVAR(current_frames_doc, 816 PyDoc_STRVAR(current_frames_doc,
817 "_current_frames() -> dictionary\n\ 817 "_current_frames() -> dictionary\n\
818 \n\ 818 \n\
823 ); 823 );
824 824
825 static PyObject * 825 static PyObject *
826 sys_current_frames(PyObject *self, PyObject *noargs) 826 sys_current_frames(PyObject *self, PyObject *noargs)
827 { 827 {
828 return _PyThread_CurrentFrames(); 828 return _PyThread_CurrentFrames();
829 } 829 }
830 830
831 PyDoc_STRVAR(call_tracing_doc, 831 PyDoc_STRVAR(call_tracing_doc,
832 "call_tracing(func, args) -> object\n\ 832 "call_tracing(func, args) -> object\n\
833 \n\ 833 \n\
837 ); 837 );
838 838
839 static PyObject * 839 static PyObject *
840 sys_call_tracing(PyObject *self, PyObject *args) 840 sys_call_tracing(PyObject *self, PyObject *args)
841 { 841 {
842 PyObject *func, *funcargs; 842 PyObject *func, *funcargs;
843 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs)) 843 if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
844 return NULL; 844 return NULL;
845 return _PyEval_CallTracing(func, funcargs); 845 return _PyEval_CallTracing(func, funcargs);
846 } 846 }
847 847
848 PyDoc_STRVAR(callstats_doc, 848 PyDoc_STRVAR(callstats_doc,
849 "callstats() -> tuple of integers\n\ 849 "callstats() -> tuple of integers\n\
850 \n\ 850 \n\
887 #endif 887 #endif
888 888
889 static PyObject * 889 static PyObject *
890 sys_clear_type_cache(PyObject* self, PyObject* args) 890 sys_clear_type_cache(PyObject* self, PyObject* args)
891 { 891 {
892 PyType_ClearCache(); 892 PyType_ClearCache();
893 Py_RETURN_NONE; 893 Py_RETURN_NONE;
894 } 894 }
895 895
896 PyDoc_STRVAR(sys_clear_type_cache__doc__, 896 PyDoc_STRVAR(sys_clear_type_cache__doc__,
897 "_clear_type_cache() -> None\n\ 897 "_clear_type_cache() -> None\n\
898 Clear the internal type lookup cache."); 898 Clear the internal type lookup cache.");
899 899
900 900
901 static PyMethodDef sys_methods[] = { 901 static PyMethodDef sys_methods[] = {
902 /* Might as well keep this in alphabetic order */ 902 /* Might as well keep this in alphabetic order */
903 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS, 903 {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
904 callstats_doc}, 904 callstats_doc},
905 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS, 905 {"_clear_type_cache", sys_clear_type_cache, METH_NOARGS,
906 sys_clear_type_cache__doc__}, 906 sys_clear_type_cache__doc__},
907 {"_current_frames", sys_current_frames, METH_NOARGS, 907 {"_current_frames", sys_current_frames, METH_NOARGS,
908 current_frames_doc}, 908 current_frames_doc},
909 {"displayhook", sys_displayhook, METH_O, displayhook_doc}, 909 {"displayhook", sys_displayhook, METH_O, displayhook_doc},
910 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc}, 910 {"exc_info", sys_exc_info, METH_NOARGS, exc_info_doc},
911 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc}, 911 {"exc_clear", sys_exc_clear, METH_NOARGS, exc_clear_doc},
912 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc}, 912 {"excepthook", sys_excepthook, METH_VARARGS, excepthook_doc},
913 {"exit", sys_exit, METH_VARARGS, exit_doc}, 913 {"exit", sys_exit, METH_VARARGS, exit_doc},
914 #ifdef Py_USING_UNICODE 914 #ifdef Py_USING_UNICODE
915 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding, 915 {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
916 METH_NOARGS, getdefaultencoding_doc}, 916 METH_NOARGS, getdefaultencoding_doc},
917 #endif 917 #endif
918 #ifdef HAVE_DLOPEN 918 #ifdef HAVE_DLOPEN
919 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS, 919 {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
920 getdlopenflags_doc}, 920 getdlopenflags_doc},
921 #endif 921 #endif
922 #ifdef COUNT_ALLOCS 922 #ifdef COUNT_ALLOCS
923 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS}, 923 {"getcounts", (PyCFunction)sys_getcounts, METH_NOARGS},
924 #endif 924 #endif
925 #ifdef DYNAMIC_EXECUTION_PROFILE 925 #ifdef DYNAMIC_EXECUTION_PROFILE
926 {"getdxp", _Py_GetDXProfile, METH_VARARGS}, 926 {"getdxp", _Py_GetDXProfile, METH_VARARGS},
927 #endif 927 #endif
928 #ifdef Py_USING_UNICODE 928 #ifdef Py_USING_UNICODE
929 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding, 929 {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
930 METH_NOARGS, getfilesystemencoding_doc}, 930 METH_NOARGS, getfilesystemencoding_doc},
931 #endif 931 #endif
932 #ifdef Py_TRACE_REFS 932 #ifdef Py_TRACE_REFS
933 {"getobjects", _Py_GetObjects, METH_VARARGS}, 933 {"getobjects", _Py_GetObjects, METH_VARARGS},
934 #endif 934 #endif
935 #ifdef Py_REF_DEBUG 935 #ifdef Py_REF_DEBUG
936 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS}, 936 {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
937 #endif 937 #endif
938 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, 938 {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
939 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS, 939 {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
940 getrecursionlimit_doc}, 940 getrecursionlimit_doc},
941 {"getsizeof", (PyCFunction)sys_getsizeof, 941 {"getsizeof", (PyCFunction)sys_getsizeof,
942 METH_VARARGS | METH_KEYWORDS, getsizeof_doc}, 942 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
943 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, 943 {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
944 #ifdef MS_WINDOWS 944 #ifdef MS_WINDOWS
945 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS, 945 {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
946 getwindowsversion_doc}, 946 getwindowsversion_doc},
947 #endif /* MS_WINDOWS */ 947 #endif /* MS_WINDOWS */
948 #ifdef USE_MALLOPT 948 #ifdef USE_MALLOPT
949 {"mdebug", sys_mdebug, METH_VARARGS}, 949 {"mdebug", sys_mdebug, METH_VARARGS},
950 #endif 950 #endif
951 #ifdef Py_USING_UNICODE 951 #ifdef Py_USING_UNICODE
952 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS, 952 {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
953 setdefaultencoding_doc}, 953 setdefaultencoding_doc},
954 #endif 954 #endif
955 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS, 955 {"setcheckinterval", sys_setcheckinterval, METH_VARARGS,
956 setcheckinterval_doc}, 956 setcheckinterval_doc},
957 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS, 957 {"getcheckinterval", sys_getcheckinterval, METH_NOARGS,
958 getcheckinterval_doc}, 958 getcheckinterval_doc},
959 #ifdef HAVE_DLOPEN 959 #ifdef HAVE_DLOPEN
960 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS, 960 {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
961 setdlopenflags_doc}, 961 setdlopenflags_doc},
962 #endif 962 #endif
963 {"setprofile", sys_setprofile, METH_O, setprofile_doc}, 963 {"setprofile", sys_setprofile, METH_O, setprofile_doc},
964 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc}, 964 {"getprofile", sys_getprofile, METH_NOARGS, getprofile_doc},
965 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS, 965 {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
966 setrecursionlimit_doc}, 966 setrecursionlimit_doc},
967 #ifdef WITH_TSC 967 #ifdef WITH_TSC
968 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc}, 968 {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
969 #endif 969 #endif
970 {"settrace", sys_settrace, METH_O, settrace_doc}, 970 {"settrace", sys_settrace, METH_O, settrace_doc},
971 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc}, 971 {"gettrace", sys_gettrace, METH_NOARGS, gettrace_doc},
972 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc}, 972 {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
973 {NULL, NULL} /* sentinel */ 973 {NULL, NULL} /* sentinel */
974 }; 974 };
975 975
976 static PyObject * 976 static PyObject *
977 list_builtin_module_names(void) 977 list_builtin_module_names(void)
978 { 978 {
979 PyObject *list = PyList_New(0); 979 PyObject *list = PyList_New(0);
980 int i; 980 int i;
981 if (list == NULL) 981 if (list == NULL)
982 return NULL; 982 return NULL;
983 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 983 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
984 PyObject *name = PyString_FromString( 984 PyObject *name = PyString_FromString(
985 PyImport_Inittab[i].name); 985 PyImport_Inittab[i].name);
986 if (name == NULL) 986 if (name == NULL)
987 break; 987 break;
988 PyList_Append(list, name); 988 PyList_Append(list, name);
989 Py_DECREF(name); 989 Py_DECREF(name);
990 } 990 }
991 if (PyList_Sort(list) != 0) { 991 if (PyList_Sort(list) != 0) {
992 Py_DECREF(list); 992 Py_DECREF(list);
993 list = NULL; 993 list = NULL;
994 } 994 }
995 if (list) { 995 if (list) {
996 PyObject *v = PyList_AsTuple(list); 996 PyObject *v = PyList_AsTuple(list);
997 Py_DECREF(list); 997 Py_DECREF(list);
998 list = v; 998 list = v;
999 } 999 }
1000 return list; 1000 return list;
1001 } 1001 }
1002 1002
1003 static PyObject *warnoptions = NULL; 1003 static PyObject *warnoptions = NULL;
1004 1004
1005 void 1005 void
1006 PySys_ResetWarnOptions(void) 1006 PySys_ResetWarnOptions(void)
1007 { 1007 {
1008 if (warnoptions == NULL || !PyList_Check(warnoptions)) 1008 if (warnoptions == NULL || !PyList_Check(warnoptions))
1009 return; 1009 return;
1010 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL); 1010 PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
1011 } 1011 }
1012 1012
1013 void 1013 void
1014 PySys_AddWarnOption(char *s) 1014 PySys_AddWarnOption(char *s)
1015 { 1015 {
1016 PyObject *str; 1016 PyObject *str;
1017 1017
1018 if (warnoptions == NULL || !PyList_Check(warnoptions)) { 1018 if (warnoptions == NULL || !PyList_Check(warnoptions)) {
1019 Py_XDECREF(warnoptions); 1019 Py_XDECREF(warnoptions);
1020 warnoptions = PyList_New(0); 1020 warnoptions = PyList_New(0);
1021 if (warnoptions == NULL) 1021 if (warnoptions == NULL)
1022 return; 1022 return;
1023 } 1023 }
1024 str = PyString_FromString(s); 1024 str = PyString_FromString(s);
1025 if (str != NULL) { 1025 if (str != NULL) {
1026 PyList_Append(warnoptions, str); 1026 PyList_Append(warnoptions, str);
1027 Py_DECREF(str); 1027 Py_DECREF(str);
1028 } 1028 }
1029 } 1029 }
1030 1030
1031 int 1031 int
1032 PySys_HasWarnOptions(void) 1032 PySys_HasWarnOptions(void)
1033 { 1033 {
1152 static const char *svn_revision; 1152 static const char *svn_revision;
1153 1153
1154 static void 1154 static void
1155 svnversion_init(void) 1155 svnversion_init(void)
1156 { 1156 {
1157 const char *python, *br_start, *br_end, *br_end2, *svnversion; 1157 const char *python, *br_start, *br_end, *br_end2, *svnversion;
1158 Py_ssize_t len; 1158 Py_ssize_t len;
1159 int istag; 1159 int istag;
1160 1160
1161 if (svn_initialized) 1161 if (svn_initialized)
1162 return; 1162 return;
1163 1163
1164 python = strstr(headurl, "/python/"); 1164 python = strstr(headurl, "/python/");
1165 if (!python) { 1165 if (!python) {
1166 /* XXX quick hack to get bzr working */ 1166 /* XXX quick hack to get bzr working */
1167 *patchlevel_revision = '\0'; 1167 *patchlevel_revision = '\0';
1168 strcpy(branch, ""); 1168 strcpy(branch, "");
1169 strcpy(shortbranch, "unknown"); 1169 strcpy(shortbranch, "unknown");
1170 svn_revision = ""; 1170 svn_revision = "";
1171 return; 1171 return;
1172 /* Py_FatalError("subversion keywords missing"); */ 1172 /* Py_FatalError("subversion keywords missing"); */
1173 } 1173 }
1174 1174
1175 br_start = python + 8; 1175 br_start = python + 8;
1176 br_end = strchr(br_start, '/'); 1176 br_end = strchr(br_start, '/');
1177 assert(br_end); 1177 assert(br_end);
1178 1178
1179 /* Works even for trunk, 1179 /* Works even for trunk,
1180 as we are in trunk/Python/sysmodule.c */ 1180 as we are in trunk/Python/sysmodule.c */
1181 br_end2 = strchr(br_end+1, '/'); 1181 br_end2 = strchr(br_end+1, '/');
1182 1182
1183 istag = strncmp(br_start, "tags", 4) == 0; 1183 istag = strncmp(br_start, "tags", 4) == 0;
1184 if (strncmp(br_start, "trunk", 5) == 0) { 1184 if (strncmp(br_start, "trunk", 5) == 0) {
1185 strcpy(branch, "trunk"); 1185 strcpy(branch, "trunk");
1186 strcpy(shortbranch, "trunk"); 1186 strcpy(shortbranch, "trunk");
1187 1187
1188 } 1188 }
1189 else if (istag || strncmp(br_start, "branches", 8) == 0) { 1189 else if (istag || strncmp(br_start, "branches", 8) == 0) {
1190 len = br_end2 - br_start; 1190 len = br_end2 - br_start;
1191 strncpy(branch, br_start, len); 1191 strncpy(branch, br_start, len);
1192 branch[len] = '\0'; 1192 branch[len] = '\0';
1193 1193
1194 len = br_end2 - (br_end + 1); 1194 len = br_end2 - (br_end + 1);
1195 strncpy(shortbranch, br_end + 1, len); 1195 strncpy(shortbranch, br_end + 1, len);
1196 shortbranch[len] = '\0'; 1196 shortbranch[len] = '\0';
1197 } 1197 }
1198 else { 1198 else {
1199 Py_FatalError("bad HeadURL"); 1199 Py_FatalError("bad HeadURL");
1200 return; 1200 return;
1201 } 1201 }
1202 1202
1203 1203
1204 svnversion = _Py_svnversion(); 1204 svnversion = _Py_svnversion();
1205 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0) 1205 if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
1206 svn_revision = svnversion; 1206 svn_revision = svnversion;
1207 else if (istag) { 1207 else if (istag) {
1208 len = strlen(_patchlevel_revision); 1208 len = strlen(_patchlevel_revision);
1209 assert(len >= 13); 1209 assert(len >= 13);
1210 assert(len < (sizeof(patchlevel_revision) + 13)); 1210 assert(len < (sizeof(patchlevel_revision) + 13));
1211 strncpy(patchlevel_revision, _patchlevel_revision + 11, 1211 strncpy(patchlevel_revision, _patchlevel_revision + 11,
1212 len - 13); 1212 len - 13);
1213 patchlevel_revision[len - 13] = '\0'; 1213 patchlevel_revision[len - 13] = '\0';
1214 svn_revision = patchlevel_revision; 1214 svn_revision = patchlevel_revision;
1215 } 1215 }
1216 else 1216 else
1217 svn_revision = ""; 1217 svn_revision = "";
1218 1218
1219 svn_initialized = 1; 1219 svn_initialized = 1;
1220 } 1220 }
1221 1221
1222 /* Return svnversion output if available. 1222 /* Return svnversion output if available.
1223 Else return Revision of patchlevel.h if on branch. 1223 Else return Revision of patchlevel.h if on branch.
1224 Else return empty string */ 1224 Else return empty string */
1225 const char* 1225 const char*
1226 Py_SubversionRevision() 1226 Py_SubversionRevision()
1227 { 1227 {
1228 svnversion_init(); 1228 svnversion_init();
1229 return svn_revision; 1229 return svn_revision;
1230 } 1230 }
1231 1231
1232 const char* 1232 const char*
1233 Py_SubversionShortBranch() 1233 Py_SubversionShortBranch()
1234 { 1234 {
1235 svnversion_init(); 1235 svnversion_init();
1236 return shortbranch; 1236 return shortbranch;
1237 } 1237 }
1238 1238
1239 1239
1240 PyDoc_STRVAR(flags__doc__, 1240 PyDoc_STRVAR(flags__doc__,
1241 "sys.flags\n\ 1241 "sys.flags\n\
1243 Flags provided through command line arguments or environment vars."); 1243 Flags provided through command line arguments or environment vars.");
1244 1244
1245 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0}; 1245 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
1246 1246
1247 static PyStructSequence_Field flags_fields[] = { 1247 static PyStructSequence_Field flags_fields[] = {
1248 {"debug", "-d"}, 1248 {"debug", "-d"},
1249 {"py3k_warning", "-3"}, 1249 {"py3k_warning", "-3"},
1250 {"division_warning", "-Q"}, 1250 {"division_warning", "-Q"},
1251 {"division_new", "-Qnew"}, 1251 {"division_new", "-Qnew"},
1252 {"inspect", "-i"}, 1252 {"inspect", "-i"},
1253 {"interactive", "-i"}, 1253 {"interactive", "-i"},
1254 {"optimize", "-O or -OO"}, 1254 {"optimize", "-O or -OO"},
1255 {"dont_write_bytecode", "-B"}, 1255 {"dont_write_bytecode", "-B"},
1256 {"no_user_site", "-s"}, 1256 {"no_user_site", "-s"},
1257 {"no_site", "-S"}, 1257 {"no_site", "-S"},
1258 {"ignore_environment", "-E"}, 1258 {"ignore_environment", "-E"},
1259 {"tabcheck", "-t or -tt"}, 1259 {"tabcheck", "-t or -tt"},
1260 {"verbose", "-v"}, 1260 {"verbose", "-v"},
1261 #ifdef RISCOS 1261 #ifdef RISCOS
1262 {"riscos_wimp", "???"}, 1262 {"riscos_wimp", "???"},
1263 #endif 1263 #endif
1264 /* {"unbuffered", "-u"}, */ 1264 /* {"unbuffered", "-u"}, */
1265 {"unicode", "-U"}, 1265 {"unicode", "-U"},
1266 /* {"skip_first", "-x"}, */ 1266 /* {"skip_first", "-x"}, */
1267 {"bytes_warning", "-b"}, 1267 {"bytes_warning", "-b"},
1268 {0} 1268 {0}
1269 }; 1269 };
1270 1270
1271 static PyStructSequence_Desc flags_desc = { 1271 static PyStructSequence_Desc flags_desc = {
1272 "sys.flags", /* name */ 1272 "sys.flags", /* name */
1273 flags__doc__, /* doc */ 1273 flags__doc__, /* doc */
1274 flags_fields, /* fields */ 1274 flags_fields, /* fields */
1275 #ifdef RISCOS 1275 #ifdef RISCOS
1276 16 1276 16
1277 #else 1277 #else
1278 15 1278 15
1279 #endif 1279 #endif
1280 }; 1280 };
1281 1281
1282 static PyObject* 1282 static PyObject*
1283 make_flags(void) 1283 make_flags(void)
1284 { 1284 {
1285 int pos = 0; 1285 int pos = 0;
1286 PyObject *seq; 1286 PyObject *seq;
1287 1287
1288 seq = PyStructSequence_New(&FlagsType); 1288 seq = PyStructSequence_New(&FlagsType);
1289 if (seq == NULL) 1289 if (seq == NULL)
1290 return NULL; 1290 return NULL;
1291 1291
1292 #define SetFlag(flag) \ 1292 #define SetFlag(flag) \
1293 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag)) 1293 PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
1294 1294
1295 SetFlag(Py_DebugFlag); 1295 SetFlag(Py_DebugFlag);
1296 SetFlag(Py_Py3kWarningFlag); 1296 SetFlag(Py_Py3kWarningFlag);
1297 SetFlag(Py_DivisionWarningFlag); 1297 SetFlag(Py_DivisionWarningFlag);
1298 SetFlag(_Py_QnewFlag); 1298 SetFlag(_Py_QnewFlag);
1299 SetFlag(Py_InspectFlag); 1299 SetFlag(Py_InspectFlag);
1300 SetFlag(Py_InteractiveFlag); 1300 SetFlag(Py_InteractiveFlag);
1301 SetFlag(Py_OptimizeFlag); 1301 SetFlag(Py_OptimizeFlag);
1302 SetFlag(Py_DontWriteBytecodeFlag); 1302 SetFlag(Py_DontWriteBytecodeFlag);
1303 SetFlag(Py_NoUserSiteDirectory); 1303 SetFlag(Py_NoUserSiteDirectory);
1304 SetFlag(Py_NoSiteFlag); 1304 SetFlag(Py_NoSiteFlag);
1305 SetFlag(Py_IgnoreEnvironmentFlag); 1305 SetFlag(Py_IgnoreEnvironmentFlag);
1306 SetFlag(Py_TabcheckFlag); 1306 SetFlag(Py_TabcheckFlag);
1307 SetFlag(Py_VerboseFlag); 1307 SetFlag(Py_VerboseFlag);
1308 #ifdef RISCOS 1308 #ifdef RISCOS
1309 SetFlag(Py_RISCOSWimpFlag); 1309 SetFlag(Py_RISCOSWimpFlag);
1310 #endif 1310 #endif
1311 /* SetFlag(saw_unbuffered_flag); */ 1311 /* SetFlag(saw_unbuffered_flag); */
1312 SetFlag(Py_UnicodeFlag); 1312 SetFlag(Py_UnicodeFlag);
1313 /* SetFlag(skipfirstline); */ 1313 /* SetFlag(skipfirstline); */
1314 SetFlag(Py_BytesWarningFlag); 1314 SetFlag(Py_BytesWarningFlag);
1315 #undef SetFlag 1315 #undef SetFlag
1316 1316
1317 if (PyErr_Occurred()) { 1317 if (PyErr_Occurred()) {
1318 return NULL; 1318 return NULL;
1319 } 1319 }
1320 return seq; 1320 return seq;
1321 } 1321 }
1322 1322
1323 PyDoc_STRVAR(version_info__doc__, 1323 PyDoc_STRVAR(version_info__doc__,
1324 "sys.version_info\n\ 1324 "sys.version_info\n\
1325 \n\ 1325 \n\
1326 Version information as a named tuple."); 1326 Version information as a named tuple.");
1327 1327
1328 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0}; 1328 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
1329 1329
1330 static PyStructSequence_Field version_info_fields[] = { 1330 static PyStructSequence_Field version_info_fields[] = {
1331 {"major", "Major release number"}, 1331 {"major", "Major release number"},
1332 {"minor", "Minor release number"}, 1332 {"minor", "Minor release number"},
1333 {"micro", "Patch release number"}, 1333 {"micro", "Patch release number"},
1334 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"}, 1334 {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
1335 {"serial", "Serial release number"}, 1335 {"serial", "Serial release number"},
1336 {0} 1336 {0}
1337 }; 1337 };
1338 1338
1339 static PyStructSequence_Desc version_info_desc = { 1339 static PyStructSequence_Desc version_info_desc = {
1340 "sys.version_info", /* name */ 1340 "sys.version_info", /* name */
1341 version_info__doc__, /* doc */ 1341 version_info__doc__, /* doc */
1342 version_info_fields, /* fields */ 1342 version_info_fields, /* fields */
1343 5 1343 5
1344 }; 1344 };
1345 1345
1346 static PyObject * 1346 static PyObject *
1347 make_version_info(void) 1347 make_version_info(void)
1348 { 1348 {
1349 PyObject *version_info; 1349 PyObject *version_info;
1350 char *s; 1350 char *s;
1351 int pos = 0; 1351 int pos = 0;
1352 1352
1353 version_info = PyStructSequence_New(&VersionInfoType); 1353 version_info = PyStructSequence_New(&VersionInfoType);
1354 if (version_info == NULL) { 1354 if (version_info == NULL) {
1355 return NULL; 1355 return NULL;
1356 } 1356 }
1357 1357
1358 /* 1358 /*
1359 * These release level checks are mutually exclusive and cover 1359 * These release level checks are mutually exclusive and cover
1360 * the field, so don't get too fancy with the pre-processor! 1360 * the field, so don't get too fancy with the pre-processor!
1361 */ 1361 */
1362 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA 1362 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
1363 s = "alpha"; 1363 s = "alpha";
1364 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA 1364 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
1365 s = "beta"; 1365 s = "beta";
1366 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA 1366 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
1367 s = "candidate"; 1367 s = "candidate";
1368 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL 1368 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
1369 s = "final"; 1369 s = "final";
1370 #endif 1370 #endif
1371 1371
1372 #define SetIntItem(flag) \ 1372 #define SetIntItem(flag) \
1373 PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag)) 1373 PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
1374 #define SetStrItem(flag) \ 1374 #define SetStrItem(flag) \
1375 PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag)) 1375 PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
1376 1376
1377 SetIntItem(PY_MAJOR_VERSION); 1377 SetIntItem(PY_MAJOR_VERSION);
1378 SetIntItem(PY_MINOR_VERSION); 1378 SetIntItem(PY_MINOR_VERSION);
1379 SetIntItem(PY_MICRO_VERSION); 1379 SetIntItem(PY_MICRO_VERSION);
1380 SetStrItem(s); 1380 SetStrItem(s);
1381 SetIntItem(PY_RELEASE_SERIAL); 1381 SetIntItem(PY_RELEASE_SERIAL);
1382 #undef SetIntItem 1382 #undef SetIntItem
1383 #undef SetStrItem 1383 #undef SetStrItem
1384 1384
1385 if (PyErr_Occurred()) { 1385 if (PyErr_Occurred()) {
1386 Py_CLEAR(version_info); 1386 Py_CLEAR(version_info);
1387 return NULL; 1387 return NULL;
1388 } 1388 }
1389 return version_info; 1389 return version_info;
1390 } 1390 }
1391 1391
1392 PyObject * 1392 PyObject *
1393 _PySys_Init(void) 1393 _PySys_Init(void)
1394 { 1394 {
1395 PyObject *m, *v, *sysdict; 1395 PyObject *m, *v, *sysdict;
1396 PyObject *sysin, *sysout, *syserr; 1396 PyObject *sysin, *sysout, *syserr;
1397 char *s; 1397 char *s;
1398 1398
1399 m = Py_InitModule3("sys", sys_methods, sys_doc); 1399 m = Py_InitModule3("sys", sys_methods, sys_doc);
1400 if (m == NULL) 1400 if (m == NULL)
1401 return NULL; 1401 return NULL;
1402 sysdict = PyModule_GetDict(m); 1402 sysdict = PyModule_GetDict(m);
1403 #define SET_SYS_FROM_STRING(key, value) \ 1403 #define SET_SYS_FROM_STRING(key, value) \
1404 v = value; \ 1404 v = value; \
1405 if (v != NULL) \ 1405 if (v != NULL) \
1406 PyDict_SetItemString(sysdict, key, v); \ 1406 PyDict_SetItemString(sysdict, key, v); \
1407 Py_XDECREF(v) 1407 Py_XDECREF(v)
1408 1408
1409 /* Check that stdin is not a directory 1409 /* Check that stdin is not a directory
1410 Using shell redirection, you can redirect stdin to a directory, 1410 Using shell redirection, you can redirect stdin to a directory,
1411 crashing the Python interpreter. Catch this common mistake here 1411 crashing the Python interpreter. Catch this common mistake here
1412 and output a useful error message. Note that under MS Windows, 1412 and output a useful error message. Note that under MS Windows,
1413 the shell already prevents that. */ 1413 the shell already prevents that. */
1414 #if !defined(MS_WINDOWS) 1414 #if !defined(MS_WINDOWS)
1415 { 1415 {
1416 struct stat sb; 1416 struct stat sb;
1417 if (fstat(fileno(stdin), &sb) == 0 && 1417 if (fstat(fileno(stdin), &sb) == 0 &&
1418 S_ISDIR(sb.st_mode)) { 1418 S_ISDIR(sb.st_mode)) {
1419 /* There's nothing more we can do. */ 1419 /* There's nothing more we can do. */
1420 /* Py_FatalError() will core dump, so just exit. */ 1420 /* Py_FatalError() will core dump, so just exit. */
1421 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n"); 1421 PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
1422 exit(EXIT_FAILURE); 1422 exit(EXIT_FAILURE);
1423 } 1423 }
1424 } 1424 }
1425 #endif 1425 #endif
1426 1426
1427 /* Closing the standard FILE* if sys.std* goes aways causes problems 1427 /* Closing the standard FILE* if sys.std* goes aways causes problems
1428 * for embedded Python usages. Closing them when somebody explicitly 1428 * for embedded Python usages. Closing them when somebody explicitly
1429 * invokes .close() might be possible, but the FAQ promises they get 1429 * invokes .close() might be possible, but the FAQ promises they get
1430 * never closed. However, we still need to get write errors when 1430 * never closed. However, we still need to get write errors when
1431 * writing fails (e.g. because stdout is redirected), so we flush the 1431 * writing fails (e.g. because stdout is redirected), so we flush the
1432 * streams and check for errors before the file objects are deleted. 1432 * streams and check for errors before the file objects are deleted.
1433 * On OS X, fflush()ing stdin causes an error, so we exempt stdin 1433 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
1434 * from that procedure. 1434 * from that procedure.
1435 */ 1435 */
1436 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL); 1436 sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
1437 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush); 1437 sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
1438 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush); 1438 syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
1439 if (PyErr_Occurred()) 1439 if (PyErr_Occurred())
1440 return NULL; 1440 return NULL;
1441 1441
1442 PyDict_SetItemString(sysdict, "stdin", sysin); 1442 PyDict_SetItemString(sysdict, "stdin", sysin);
1443 PyDict_SetItemString(sysdict, "stdout", sysout); 1443 PyDict_SetItemString(sysdict, "stdout", sysout);
1444 PyDict_SetItemString(sysdict, "stderr", syserr); 1444 PyDict_SetItemString(sysdict, "stderr", syserr);
1445 /* Make backup copies for cleanup */ 1445 /* Make backup copies for cleanup */
1446 PyDict_SetItemString(sysdict, "__stdin__", sysin); 1446 PyDict_SetItemString(sysdict, "__stdin__", sysin);
1447 PyDict_SetItemString(sysdict, "__stdout__", sysout); 1447 PyDict_SetItemString(sysdict, "__stdout__", sysout);
1448 PyDict_SetItemString(sysdict, "__stderr__", syserr); 1448 PyDict_SetItemString(sysdict, "__stderr__", syserr);
1449 PyDict_SetItemString(sysdict, "__displayhook__", 1449 PyDict_SetItemString(sysdict, "__displayhook__",
1450 PyDict_GetItemString(sysdict, "displayhook")); 1450 PyDict_GetItemString(sysdict, "displayhook"));
1451 PyDict_SetItemString(sysdict, "__excepthook__", 1451 PyDict_SetItemString(sysdict, "__excepthook__",
1452 PyDict_GetItemString(sysdict, "excepthook")); 1452 PyDict_GetItemString(sysdict, "excepthook"));
1453 Py_XDECREF(sysin); 1453 Py_XDECREF(sysin);
1454 Py_XDECREF(sysout); 1454 Py_XDECREF(sysout);
1455 Py_XDECREF(syserr); 1455 Py_XDECREF(syserr);
1456 1456
1457 SET_SYS_FROM_STRING("version", 1457 SET_SYS_FROM_STRING("version",
1458 PyString_FromString(Py_GetVersion())); 1458 PyString_FromString(Py_GetVersion()));
1459 SET_SYS_FROM_STRING("hexversion", 1459 SET_SYS_FROM_STRING("hexversion",
1460 PyInt_FromLong(PY_VERSION_HEX)); 1460 PyInt_FromLong(PY_VERSION_HEX));
1461 svnversion_init(); 1461 svnversion_init();
1462 SET_SYS_FROM_STRING("subversion", 1462 SET_SYS_FROM_STRING("subversion",
1463 Py_BuildValue("(ssz)", "CPython", branch, 1463 Py_BuildValue("(ssz)", "CPython", branch,
1464 svn_revision)); 1464 svn_revision));
1465 SET_SYS_FROM_STRING("dont_write_bytecode", 1465 SET_SYS_FROM_STRING("dont_write_bytecode",
1466 PyBool_FromLong(Py_DontWriteBytecodeFlag)); 1466 PyBool_FromLong(Py_DontWriteBytecodeFlag));
1467 SET_SYS_FROM_STRING("api_version", 1467 SET_SYS_FROM_STRING("api_version",
1468 PyInt_FromLong(PYTHON_API_VERSION)); 1468 PyInt_FromLong(PYTHON_API_VERSION));
1469 SET_SYS_FROM_STRING("copyright", 1469 SET_SYS_FROM_STRING("copyright",
1470 PyString_FromString(Py_GetCopyright())); 1470 PyString_FromString(Py_GetCopyright()));
1471 SET_SYS_FROM_STRING("platform", 1471 SET_SYS_FROM_STRING("platform",
1472 PyString_FromString(Py_GetPlatform())); 1472 PyString_FromString(Py_GetPlatform()));
1473 SET_SYS_FROM_STRING("executable", 1473 SET_SYS_FROM_STRING("executable",
1474 PyString_FromString(Py_GetProgramFullPath())); 1474 PyString_FromString(Py_GetProgramFullPath()));
1475 SET_SYS_FROM_STRING("prefix", 1475 SET_SYS_FROM_STRING("prefix",
1476 PyString_FromString(Py_GetPrefix())); 1476 PyString_FromString(Py_GetPrefix()));
1477 SET_SYS_FROM_STRING("exec_prefix", 1477 SET_SYS_FROM_STRING("exec_prefix",
1478 PyString_FromString(Py_GetExecPrefix())); 1478 PyString_FromString(Py_GetExecPrefix()));
1479 SET_SYS_FROM_STRING("maxsize", 1479 SET_SYS_FROM_STRING("maxsize",
1480 PyInt_FromSsize_t(PY_SSIZE_T_MAX)); 1480 PyInt_FromSsize_t(PY_SSIZE_T_MAX));
1481 SET_SYS_FROM_STRING("maxint", 1481 SET_SYS_FROM_STRING("maxint",
1482 PyInt_FromLong(PyInt_GetMax())); 1482 PyInt_FromLong(PyInt_GetMax()));
1483 SET_SYS_FROM_STRING("py3kwarning", 1483 SET_SYS_FROM_STRING("py3kwarning",
1484 PyBool_FromLong(Py_Py3kWarningFlag)); 1484 PyBool_FromLong(Py_Py3kWarningFlag));
1485 SET_SYS_FROM_STRING("float_info", 1485 SET_SYS_FROM_STRING("float_info",
1486 PyFloat_GetInfo()); 1486 PyFloat_GetInfo());
1487 SET_SYS_FROM_STRING("long_info", 1487 SET_SYS_FROM_STRING("long_info",
1488 PyLong_GetInfo()); 1488 PyLong_GetInfo());
1489 #ifdef Py_USING_UNICODE 1489 #ifdef Py_USING_UNICODE
1490 SET_SYS_FROM_STRING("maxunicode", 1490 SET_SYS_FROM_STRING("maxunicode",
1491 PyInt_FromLong(PyUnicode_GetMax())); 1491 PyInt_FromLong(PyUnicode_GetMax()));
1492 #endif 1492 #endif
1493 SET_SYS_FROM_STRING("builtin_module_names", 1493 SET_SYS_FROM_STRING("builtin_module_names",
1494 list_builtin_module_names()); 1494 list_builtin_module_names());
1495 { 1495 {
1496 /* Assumes that longs are at least 2 bytes long. 1496 /* Assumes that longs are at least 2 bytes long.
1497 Should be safe! */ 1497 Should be safe! */
1498 unsigned long number = 1; 1498 unsigned long number = 1;
1499 char *value; 1499 char *value;
1500 1500
1501 s = (char *) &number; 1501 s = (char *) &number;
1502 if (s[0] == 0) 1502 if (s[0] == 0)
1503 value = "big"; 1503 value = "big";
1504 else 1504 else
1505 value = "little"; 1505 value = "little";
1506 SET_SYS_FROM_STRING("byteorder", 1506 SET_SYS_FROM_STRING("byteorder",
1507 PyString_FromString(value)); 1507 PyString_FromString(value));
1508 } 1508 }
1509 #ifdef MS_COREDLL 1509 #ifdef MS_COREDLL
1510 SET_SYS_FROM_STRING("dllhandle", 1510 SET_SYS_FROM_STRING("dllhandle",
1511 PyLong_FromVoidPtr(PyWin_DLLhModule)); 1511 PyLong_FromVoidPtr(PyWin_DLLhModule));
1512 SET_SYS_FROM_STRING("winver", 1512 SET_SYS_FROM_STRING("winver",
1513 PyString_FromString(PyWin_DLLVersionString)); 1513 PyString_FromString(PyWin_DLLVersionString));
1514 #endif 1514 #endif
1515 if (warnoptions == NULL) { 1515 if (warnoptions == NULL) {
1516 warnoptions = PyList_New(0); 1516 warnoptions = PyList_New(0);
1517 } 1517 }
1518 else { 1518 else {
1519 Py_INCREF(warnoptions); 1519 Py_INCREF(warnoptions);
1520 } 1520 }
1521 if (warnoptions != NULL) { 1521 if (warnoptions != NULL) {
1522 PyDict_SetItemString(sysdict, "warnoptions", warnoptions); 1522 PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
1523 } 1523 }
1524 1524
1525 /* version_info */ 1525 /* version_info */
1526 if (VersionInfoType.tp_name == 0) 1526 if (VersionInfoType.tp_name == 0)
1527 PyStructSequence_InitType(&VersionInfoType, &version_info_desc); 1527 PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
1528 SET_SYS_FROM_STRING("version_info", make_version_info()); 1528 SET_SYS_FROM_STRING("version_info", make_version_info());
1529 /* prevent user from creating new instances */ 1529 /* prevent user from creating new instances */
1530 VersionInfoType.tp_init = NULL; 1530 VersionInfoType.tp_init = NULL;
1531 VersionInfoType.tp_new = NULL; 1531 VersionInfoType.tp_new = NULL;
1532 1532
1533 /* flags */ 1533 /* flags */
1534 if (FlagsType.tp_name == 0) 1534 if (FlagsType.tp_name == 0)
1535 PyStructSequence_InitType(&FlagsType, &flags_desc); 1535 PyStructSequence_InitType(&FlagsType, &flags_desc);
1536 SET_SYS_FROM_STRING("flags", make_flags()); 1536 SET_SYS_FROM_STRING("flags", make_flags());
1537 /* prevent user from creating new instances */ 1537 /* prevent user from creating new instances */
1538 FlagsType.tp_init = NULL; 1538 FlagsType.tp_init = NULL;
1539 FlagsType.tp_new = NULL; 1539 FlagsType.tp_new = NULL;
1540 1540
1541 1541
1542 #if defined(MS_WINDOWS) 1542 #if defined(MS_WINDOWS)
1543 /* getwindowsversion */ 1543 /* getwindowsversion */
1544 if (WindowsVersionType.tp_name == 0) 1544 if (WindowsVersionType.tp_name == 0)
1545 PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc); 1545 PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
1546 /* prevent user from creating new instances */ 1546 /* prevent user from creating new instances */
1547 WindowsVersionType.tp_init = NULL; 1547 WindowsVersionType.tp_init = NULL;
1548 WindowsVersionType.tp_new = NULL; 1548 WindowsVersionType.tp_new = NULL;
1549 #endif 1549 #endif
1550 1550
1551 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */ 1551 /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
1552 #ifndef PY_NO_SHORT_FLOAT_REPR 1552 #ifndef PY_NO_SHORT_FLOAT_REPR
1553 SET_SYS_FROM_STRING("float_repr_style", 1553 SET_SYS_FROM_STRING("float_repr_style",
1554 PyString_FromString("short")); 1554 PyString_FromString("short"));
1555 #else 1555 #else
1556 SET_SYS_FROM_STRING("float_repr_style", 1556 SET_SYS_FROM_STRING("float_repr_style",
1557 PyString_FromString("legacy")); 1557 PyString_FromString("legacy"));
1558 #endif 1558 #endif
1559 1559
1560 #undef SET_SYS_FROM_STRING 1560 #undef SET_SYS_FROM_STRING
1561 if (PyErr_Occurred()) 1561 if (PyErr_Occurred())
1562 return NULL; 1562 return NULL;
1563 return m; 1563 return m;
1564 } 1564 }
1565 1565
1566 static PyObject * 1566 static PyObject *
1567 makepathobject(char *path, int delim) 1567 makepathobject(char *path, int delim)
1568 { 1568 {
1569 int i, n; 1569 int i, n;
1570 char *p; 1570 char *p;
1571 PyObject *v, *w; 1571 PyObject *v, *w;
1572 1572
1573 n = 1; 1573 n = 1;
1574 p = path; 1574 p = path;
1575 while ((p = strchr(p, delim)) != NULL) { 1575 while ((p = strchr(p, delim)) != NULL) {
1576 n++; 1576 n++;
1577 p++; 1577 p++;
1578 } 1578 }
1579 v = PyList_New(n); 1579 v = PyList_New(n);
1580 if (v == NULL) 1580 if (v == NULL)
1581 return NULL; 1581 return NULL;
1582 for (i = 0; ; i++) { 1582 for (i = 0; ; i++) {
1583 p = strchr(path, delim); 1583 p = strchr(path, delim);
1584 if (p == NULL) 1584 if (p == NULL)
1585 p = strchr(path, '\0'); /* End of string */ 1585 p = strchr(path, '\0'); /* End of string */
1586 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path)); 1586 w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
1587 if (w == NULL) { 1587 if (w == NULL) {
1588 Py_DECREF(v); 1588 Py_DECREF(v);
1589 return NULL; 1589 return NULL;
1590 } 1590 }
1591 PyList_SetItem(v, i, w); 1591 PyList_SetItem(v, i, w);
1592 if (*p == '\0') 1592 if (*p == '\0')
1593 break; 1593 break;
1594 path = p+1; 1594 path = p+1;
1595 } 1595 }
1596 return v; 1596 return v;
1597 } 1597 }
1598 1598
1599 void 1599 void
1600 PySys_SetPath(char *path) 1600 PySys_SetPath(char *path)
1601 { 1601 {
1602 PyObject *v; 1602 PyObject *v;
1603 if ((v = makepathobject(path, DELIM)) == NULL) 1603 if ((v = makepathobject(path, DELIM)) == NULL)
1604 Py_FatalError("can't create sys.path"); 1604 Py_FatalError("can't create sys.path");
1605 if (PySys_SetObject("path", v) != 0) 1605 if (PySys_SetObject("path", v) != 0)
1606 Py_FatalError("can't assign sys.path"); 1606 Py_FatalError("can't assign sys.path");
1607 Py_DECREF(v); 1607 Py_DECREF(v);
1608 } 1608 }
1609 1609
1610 static PyObject * 1610 static PyObject *
1611 makeargvobject(int argc, char **argv) 1611 makeargvobject(int argc, char **argv)
1612 { 1612 {
1613 PyObject *av; 1613 PyObject *av;
1614 if (argc <= 0 || argv == NULL) { 1614 if (argc <= 0 || argv == NULL) {
1615 /* Ensure at least one (empty) argument is seen */ 1615 /* Ensure at least one (empty) argument is seen */
1616 static char *empty_argv[1] = {""}; 1616 static char *empty_argv[1] = {""};
1617 argv = empty_argv; 1617 argv = empty_argv;
1618 argc = 1; 1618 argc = 1;
1619 } 1619 }
1620 av = PyList_New(argc); 1620 av = PyList_New(argc);
1621 if (av != NULL) { 1621 if (av != NULL) {
1622 int i; 1622 int i;
1623 for (i = 0; i < argc; i++) { 1623 for (i = 0; i < argc; i++) {
1624 #ifdef __VMS 1624 #ifdef __VMS
1625 PyObject *v; 1625 PyObject *v;
1626 1626
1627 /* argv[0] is the script pathname if known */ 1627 /* argv[0] is the script pathname if known */
1628 if (i == 0) { 1628 if (i == 0) {
1629 char* fn = decc$translate_vms(argv[0]); 1629 char* fn = decc$translate_vms(argv[0]);
1630 if ((fn == (char *)0) || fn == (char *)-1) 1630 if ((fn == (char *)0) || fn == (char *)-1)
1631 v = PyString_FromString(argv[0]); 1631 v = PyString_FromString(argv[0]);
1632 else 1632 else
1633 v = PyString_FromString( 1633 v = PyString_FromString(
1634 decc$translate_vms(argv[0])); 1634 decc$translate_vms(argv[0]));
1635 } else 1635 } else
1636 v = PyString_FromString(argv[i]); 1636 v = PyString_FromString(argv[i]);
1637 #else 1637 #else
1638 PyObject *v = PyString_FromString(argv[i]); 1638 PyObject *v = PyString_FromString(argv[i]);
1639 #endif 1639 #endif
1640 if (v == NULL) { 1640 if (v == NULL) {
1641 Py_DECREF(av); 1641 Py_DECREF(av);
1642 av = NULL; 1642 av = NULL;
1643 break; 1643 break;
1644 } 1644 }
1645 PyList_SetItem(av, i, v); 1645 PyList_SetItem(av, i, v);
1646 } 1646 }
1647 } 1647 }
1648 return av; 1648 return av;
1649 } 1649 }
1650 1650
1651 void 1651 void
1652 PySys_SetArgv(int argc, char **argv) 1652 PySys_SetArgv(int argc, char **argv)
1653 { 1653 {
1654 #if defined(HAVE_REALPATH) 1654 #if defined(HAVE_REALPATH)
1655 char fullpath[MAXPATHLEN]; 1655 char fullpath[MAXPATHLEN];
1656 #elif defined(MS_WINDOWS) && !defined(MS_WINCE) 1656 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
1657 char fullpath[MAX_PATH]; 1657 char fullpath[MAX_PATH];
1658 #endif 1658 #endif
1659 PyObject *av = makeargvobject(argc, argv); 1659 PyObject *av = makeargvobject(argc, argv);
1660 PyObject *path = PySys_GetObject("path"); 1660 PyObject *path = PySys_GetObject("path");
1661 if (av == NULL) 1661 if (av == NULL)
1662 Py_FatalError("no mem for sys.argv"); 1662 Py_FatalError("no mem for sys.argv");
1663 if (PySys_SetObject("argv", av) != 0) 1663 if (PySys_SetObject("argv", av) != 0)
1664 Py_FatalError("can't assign sys.argv"); 1664 Py_FatalError("can't assign sys.argv");
1665 if (path != NULL) { 1665 if (path != NULL) {
1666 char *argv0 = argv[0]; 1666 char *argv0 = argv[0];
1667 char *p = NULL; 1667 char *p = NULL;
1668 Py_ssize_t n = 0; 1668 Py_ssize_t n = 0;
1669 PyObject *a; 1669 PyObject *a;
1670 #ifdef HAVE_READLINK 1670 #ifdef HAVE_READLINK
1671 char link[MAXPATHLEN+1]; 1671 char link[MAXPATHLEN+1];
1672 char argv0copy[2*MAXPATHLEN+1]; 1672 char argv0copy[2*MAXPATHLEN+1];
1673 int nr = 0; 1673 int nr = 0;
1674 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) 1674 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
1675 nr = readlink(argv0, link, MAXPATHLEN); 1675 nr = readlink(argv0, link, MAXPATHLEN);
1676 if (nr > 0) { 1676 if (nr > 0) {
1677 /* It's a symlink */ 1677 /* It's a symlink */
1678 link[nr] = '\0'; 1678 link[nr] = '\0';
1679 if (link[0] == SEP) 1679 if (link[0] == SEP)
1680 argv0 = link; /* Link to absolute path */ 1680 argv0 = link; /* Link to absolute path */
1681 else if (strchr(link, SEP) == NULL) 1681 else if (strchr(link, SEP) == NULL)
1682 ; /* Link without path */ 1682 ; /* Link without path */
1683 else { 1683 else {
1684 /* Must join(dirname(argv0), link) */ 1684 /* Must join(dirname(argv0), link) */
1685 char *q = strrchr(argv0, SEP); 1685 char *q = strrchr(argv0, SEP);
1686 if (q == NULL) 1686 if (q == NULL)
1687 argv0 = link; /* argv0 without path */ 1687 argv0 = link; /* argv0 without path */
1688 else { 1688 else {
1689 /* Must make a copy */ 1689 /* Must make a copy */
1690 strcpy(argv0copy, argv0); 1690 strcpy(argv0copy, argv0);
1691 q = strrchr(argv0copy, SEP); 1691 q = strrchr(argv0copy, SEP);
1692 strcpy(q+1, link); 1692 strcpy(q+1, link);
1693 argv0 = argv0copy; 1693 argv0 = argv0copy;
1694 } 1694 }
1695 } 1695 }
1696 } 1696 }
1697 #endif /* HAVE_READLINK */ 1697 #endif /* HAVE_READLINK */
1698 #if SEP == '\\' /* Special case for MS filename syntax */ 1698 #if SEP == '\\' /* Special case for MS filename syntax */
1699 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1699 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1700 char *q; 1700 char *q;
1701 #if defined(MS_WINDOWS) && !defined(MS_WINCE) 1701 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
1702 /* This code here replaces the first element in argv with the full 1702 /* This code here replaces the first element in argv with the full
1703 path that it represents. Under CE, there are no relative paths so 1703 path that it represents. Under CE, there are no relative paths so
1704 the argument must be the full path anyway. */ 1704 the argument must be the full path anyway. */
1705 char *ptemp; 1705 char *ptemp;
1706 if (GetFullPathName(argv0, 1706 if (GetFullPathName(argv0,
1707 sizeof(fullpath), 1707 sizeof(fullpath),
1708 fullpath, 1708 fullpath,
1709 &ptemp)) { 1709 &ptemp)) {
1710 argv0 = fullpath; 1710 argv0 = fullpath;
1711 } 1711 }
1712 #endif 1712 #endif
1713 p = strrchr(argv0, SEP); 1713 p = strrchr(argv0, SEP);
1714 /* Test for alternate separator */ 1714 /* Test for alternate separator */
1715 q = strrchr(p ? p : argv0, '/'); 1715 q = strrchr(p ? p : argv0, '/');
1716 if (q != NULL) 1716 if (q != NULL)
1717 p = q; 1717 p = q;
1718 if (p != NULL) { 1718 if (p != NULL) {
1719 n = p + 1 - argv0; 1719 n = p + 1 - argv0;
1720 if (n > 1 && p[-1] != ':') 1720 if (n > 1 && p[-1] != ':')
1721 n--; /* Drop trailing separator */ 1721 n--; /* Drop trailing separator */
1722 } 1722 }
1723 } 1723 }
1724 #else /* All other filename syntaxes */ 1724 #else /* All other filename syntaxes */
1725 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) { 1725 if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
1726 #if defined(HAVE_REALPATH) 1726 #if defined(HAVE_REALPATH)
1727 if (realpath(argv0, fullpath)) { 1727 if (realpath(argv0, fullpath)) {
1728 argv0 = fullpath; 1728 argv0 = fullpath;
1729 } 1729 }
1730 #endif 1730 #endif
1731 p = strrchr(argv0, SEP); 1731 p = strrchr(argv0, SEP);
1732 } 1732 }
1733 if (p != NULL) { 1733 if (p != NULL) {
1734 #ifndef RISCOS 1734 #ifndef RISCOS
1735 n = p + 1 - argv0; 1735 n = p + 1 - argv0;
1736 #else /* don't include trailing separator */ 1736 #else /* don't include trailing separator */
1737 n = p - argv0; 1737 n = p - argv0;
1738 #endif /* RISCOS */ 1738 #endif /* RISCOS */
1739 #if SEP == '/' /* Special case for Unix filename syntax */ 1739 #if SEP == '/' /* Special case for Unix filename syntax */
1740 if (n > 1) 1740 if (n > 1)
1741 n--; /* Drop trailing separator */ 1741 n--; /* Drop trailing separator */
1742 #endif /* Unix */ 1742 #endif /* Unix */
1743 } 1743 }
1744 #endif /* All others */ 1744 #endif /* All others */
1745 a = PyString_FromStringAndSize(argv0, n); 1745 a = PyString_FromStringAndSize(argv0, n);
1746 if (a == NULL) 1746 if (a == NULL)
1747 Py_FatalError("no mem for sys.path insertion"); 1747 Py_FatalError("no mem for sys.path insertion");
1748 if (PyList_Insert(path, 0, a) < 0) 1748 if (PyList_Insert(path, 0, a) < 0)
1749 Py_FatalError("sys.path.insert(0) failed"); 1749 Py_FatalError("sys.path.insert(0) failed");
1750 Py_DECREF(a); 1750 Py_DECREF(a);
1751 } 1751 }
1752 Py_DECREF(av); 1752 Py_DECREF(av);
1753 } 1753 }
1754 1754
1755 1755
1756 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface. 1756 /* APIs to write to sys.stdout or sys.stderr using a printf-like interface.
1757 Adapted from code submitted by Just van Rossum. 1757 Adapted from code submitted by Just van Rossum.
1778 */ 1778 */
1779 1779
1780 static void 1780 static void
1781 mywrite(char *name, FILE *fp, const char *format, va_list va) 1781 mywrite(char *name, FILE *fp, const char *format, va_list va)
1782 { 1782 {
1783 PyObject *file; 1783 PyObject *file;
1784 PyObject *error_type, *error_value, *error_traceback; 1784 PyObject *error_type, *error_value, *error_traceback;
1785 1785
1786 PyErr_Fetch(&error_type, &error_value, &error_traceback); 1786 PyErr_Fetch(&error_type, &error_value, &error_traceback);
1787 file = PySys_GetObject(name); 1787 file = PySys_GetObject(name);
1788 if (file == NULL || PyFile_AsFile(file) == fp) 1788 if (file == NULL || PyFile_AsFile(file) == fp)
1789 vfprintf(fp, format, va); 1789 vfprintf(fp, format, va);
1790 else { 1790 else {
1791 char buffer[1001]; 1791 char buffer[1001];
1792 const int written = PyOS_vsnprintf(buffer, sizeof(buffer), 1792 const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
1793 format, va); 1793 format, va);
1794 if (PyFile_WriteString(buffer, file) != 0) { 1794 if (PyFile_WriteString(buffer, file) != 0) {
1795 PyErr_Clear(); 1795 PyErr_Clear();
1796 fputs(buffer, fp); 1796 fputs(buffer, fp);
1797 } 1797 }
1798 if (written < 0 || (size_t)written >= sizeof(buffer)) { 1798 if (written < 0 || (size_t)written >= sizeof(buffer)) {
1799 const char *truncated = "... truncated"; 1799 const char *truncated = "... truncated";
1800 if (PyFile_WriteString(truncated, file) != 0) { 1800 if (PyFile_WriteString(truncated, file) != 0) {
1801 PyErr_Clear(); 1801 PyErr_Clear();
1802 fputs(truncated, fp); 1802 fputs(truncated, fp);
1803 } 1803 }
1804 } 1804 }
1805 } 1805 }
1806 PyErr_Restore(error_type, error_value, error_traceback); 1806 PyErr_Restore(error_type, error_value, error_traceback);
1807 } 1807 }
1808 1808
1809 void 1809 void
1810 PySys_WriteStdout(const char *format, ...) 1810 PySys_WriteStdout(const char *format, ...)
1811 { 1811 {
1812 va_list va; 1812 va_list va;
1813 1813
1814 va_start(va, format); 1814 va_start(va, format);
1815 mywrite("stdout", stdout, format, va); 1815 mywrite("stdout", stdout, format, va);
1816 va_end(va); 1816 va_end(va);
1817 } 1817 }
1818 1818
1819 void 1819 void
1820 PySys_WriteStderr(const char *format, ...) 1820 PySys_WriteStderr(const char *format, ...)
1821 { 1821 {
1822 va_list va; 1822 va_list va;
1823 1823
1824 va_start(va, format); 1824 va_start(va, format);
1825 mywrite("stderr", stderr, format, va); 1825 mywrite("stderr", stderr, format, va);
1826 va_end(va); 1826 va_end(va);
1827 } 1827 }