static void flush_io(void) { PyObject *f, *r; PyObject *type, *value, *traceback; /* Save the current exception */ PyErr_Fetch(&type, &value, &traceback); f = _PySys_GetObjectId(&PyId_stderr); if (f != NULL) { r = _PyObject_CallMethodId(f, &PyId_flush, NULL); if (r) Py_DECREF(r); else PyErr_Clear(); } f = _PySys_GetObjectId(&PyId_stdout); if (f != NULL) { r = _PyObject_CallMethodId(f, &PyId_flush, NULL); if (r) Py_DECREF(r); else PyErr_Clear(); } PyErr_Restore(type, value, traceback); }
static int flush_std_files(void) { PyObject *fout = _PySys_GetObjectId(&PyId_stdout); PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); PyObject *tmp; int status = 0; if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { tmp = _PyObject_CallMethodId(fout, &PyId_flush, ""); if (tmp == NULL) { PyErr_WriteUnraisable(fout); status = -1; } else Py_DECREF(tmp); } if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { tmp = _PyObject_CallMethodId(ferr, &PyId_flush, ""); if (tmp == NULL) { PyErr_Clear(); status = -1; } else Py_DECREF(tmp); } return status; }
static PyObject * _io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n) /*[clinic end generated code: output=6cdeb731e3c9f13c input=b6d0dcf6417d1374]*/ { PyObject *b, *res; if (n < 0) { _Py_IDENTIFIER(readall); return _PyObject_CallMethodId(self, &PyId_readall, NULL); } /* TODO: allocate a bytes object directly instead and manually construct a writable memoryview pointing to it. */ b = PyByteArray_FromStringAndSize(NULL, n); if (b == NULL) return NULL; res = PyObject_CallMethodObjArgs(self, _PyIO_str_readinto, b, NULL); if (res == NULL || res == Py_None) { Py_DECREF(b); return res; } n = PyNumber_AsSsize_t(res, PyExc_ValueError); Py_DECREF(res); if (n == -1 && PyErr_Occurred()) { Py_DECREF(b); return NULL; } res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n); Py_DECREF(b); return res; }
Registers an adapter with pysqlite's adapter registry. Non-standard."); static PyObject* module_register_converter(PyObject* self, PyObject* args) { PyObject* orig_name; PyObject* name = NULL; PyObject* callable; PyObject* retval = NULL; _Py_IDENTIFIER(upper); if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) { return NULL; } /* convert the name to upper case */ name = _PyObject_CallMethodId(orig_name, &PyId_upper, NULL); if (!name) { goto error; } if (PyDict_SetItem(converters, name, callable) != 0) { goto error; } Py_INCREF(Py_None); retval = Py_None; error: Py_XDECREF(name); return retval; }
static PyObject * iobase_tell(PyObject *self, PyObject *args) { _Py_IDENTIFIER(seek); return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1); }
static PyObject * mmap__exit__method(PyObject *self, PyObject *args) { _Py_IDENTIFIER(close); return _PyObject_CallMethodId(self, &PyId_close, NULL); }
static PyObject* faulthandler_get_fileno(PyObject *file, int *p_fd) { PyObject *result; long fd_long; int fd; if (file == NULL || file == Py_None) { file = _PySys_GetObjectId(&PyId_stderr); if (file == NULL) { PyErr_SetString(PyExc_RuntimeError, "unable to get sys.stderr"); return NULL; } if (file == Py_None) { PyErr_SetString(PyExc_RuntimeError, "sys.stderr is None"); return NULL; } } result = _PyObject_CallMethodId(file, &PyId_fileno, ""); if (result == NULL) return NULL; fd = -1; if (PyLong_Check(result)) { fd_long = PyLong_AsLong(result); if (0 <= fd_long && fd_long < INT_MAX) fd = (int)fd_long; } Py_DECREF(result); if (fd == -1) { PyErr_SetString(PyExc_RuntimeError, "file.fileno() is not a valid file descriptor"); return NULL; } result = _PyObject_CallMethodId(file, &PyId_flush, ""); if (result != NULL) Py_DECREF(result); else { /* ignore flush() error */ PyErr_Clear(); } *p_fd = fd; return file; }
static PyObject * _io__IOBase_tell_impl(PyObject *self) /*[clinic end generated code: output=89a1c0807935abe2 input=04e615fec128801f]*/ { _Py_IDENTIFIER(seek); return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1); }
static PyObject * oss_exit(PyObject *self, PyObject *unused) { _Py_IDENTIFIER(close); PyObject *ret = _PyObject_CallMethodId(self, &PyId_close, NULL); if (!ret) return NULL; Py_DECREF(ret); Py_RETURN_NONE; }
/* Get the variable part of a module's export symbol name. * Returns a bytes instance. For non-ASCII-named modules, the name is * encoded as per PEP 489. * The hook_prefix pointer is set to either ascii_only_prefix or * nonascii_prefix, as appropriate. */ static PyObject * get_encoded_name(PyObject *name, const char **hook_prefix) { PyObject *tmp; PyObject *encoded = NULL; PyObject *modname = NULL; Py_ssize_t name_len, lastdot; _Py_IDENTIFIER(replace); /* Get the short name (substring after last dot) */ name_len = PyUnicode_GetLength(name); lastdot = PyUnicode_FindChar(name, '.', 0, name_len, -1); if (lastdot < -1) { return NULL; } else if (lastdot >= 0) { tmp = PyUnicode_Substring(name, lastdot + 1, name_len); if (tmp == NULL) return NULL; name = tmp; /* "name" now holds a new reference to the substring */ } else { Py_INCREF(name); } /* Encode to ASCII or Punycode, as needed */ encoded = PyUnicode_AsEncodedString(name, "ascii", NULL); if (encoded != NULL) { *hook_prefix = ascii_only_prefix; } else { if (PyErr_ExceptionMatches(PyExc_UnicodeEncodeError)) { PyErr_Clear(); encoded = PyUnicode_AsEncodedString(name, "punycode", NULL); if (encoded == NULL) { goto error; } *hook_prefix = nonascii_prefix; } else { goto error; } } /* Replace '-' by '_' */ modname = _PyObject_CallMethodId(encoded, &PyId_replace, "cc", '-', '_'); if (modname == NULL) goto error; Py_DECREF(name); Py_DECREF(encoded); return modname; error: Py_DECREF(name); Py_XDECREF(encoded); return NULL; }
static PyObject * _io__RawIOBase_readall_impl(PyObject *self) /*[clinic end generated code: output=1987b9ce929425a0 input=688874141213622a]*/ { int r; PyObject *chunks = PyList_New(0); PyObject *result; if (chunks == NULL) return NULL; while (1) { PyObject *data = _PyObject_CallMethodId(self, &PyId_read, "i", DEFAULT_BUFFER_SIZE); if (!data) { /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR occurs so we needn't do it ourselves. */ if (_PyIO_trap_eintr()) { continue; } Py_DECREF(chunks); return NULL; } if (data == Py_None) { if (PyList_GET_SIZE(chunks) == 0) { Py_DECREF(chunks); return data; } Py_DECREF(data); break; } if (!PyBytes_Check(data)) { Py_DECREF(chunks); Py_DECREF(data); PyErr_SetString(PyExc_TypeError, "read() should return bytes"); return NULL; } if (PyBytes_GET_SIZE(data) == 0) { /* EOF */ Py_DECREF(data); break; } r = PyList_Append(chunks, data); Py_DECREF(data); if (r < 0) { Py_DECREF(chunks); return NULL; } } result = _PyBytes_Join(_PyIO_empty_bytes, chunks); Py_DECREF(chunks); return result; }
static PyObject * iobase_readlines(PyObject *self, PyObject *args) { Py_ssize_t hint = -1, length = 0; PyObject *result; if (!PyArg_ParseTuple(args, "|O&:readlines", &_PyIO_ConvertSsize_t, &hint)) { return NULL; } result = PyList_New(0); if (result == NULL) return NULL; if (hint <= 0) { /* XXX special-casing this made sense in the Python version in order to remove the bytecode interpretation overhead, but it could probably be removed here. */ _Py_IDENTIFIER(extend); PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self); if (ret == NULL) { Py_DECREF(result); return NULL; } Py_DECREF(ret); return result; } while (1) { PyObject *line = PyIter_Next(self); if (line == NULL) { if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } else break; /* StopIteration raised */ } if (PyList_Append(result, line) < 0) { Py_DECREF(line); Py_DECREF(result); return NULL; } length += PyObject_Size(line); Py_DECREF(line); if (length > hint) break; } return result; }
/* Given the gc module call gc.enable() and return 0 on success. */ static int _enable_gc(PyObject *gc_module) { PyObject *result; _Py_IDENTIFIER(enable); result = _PyObject_CallMethodId(gc_module, &PyId_enable, NULL); if (result == NULL) return 1; Py_DECREF(result); return 0; }
static FNFCISTATUS(cb_status) { if (pv) { _Py_IDENTIFIER(status); PyObject *result = _PyObject_CallMethodId(pv, &PyId_status, "iii", typeStatus, cb1, cb2); if (result == NULL) return -1; Py_DECREF(result); } return 0; }
static PyObject * rawiobase_readall(PyObject *self, PyObject *args) { int r; PyObject *chunks = PyList_New(0); PyObject *result; if (chunks == NULL) return NULL; while (1) { _Py_IDENTIFIER(read); PyObject *data = _PyObject_CallMethodId(self, &PyId_read, "i", DEFAULT_BUFFER_SIZE); if (!data) { /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR occurs so we needn't do it ourselves. */ if (_PyIO_trap_eintr()) { continue; } Py_DECREF(chunks); return NULL; } if (data == Py_None) { if (PyList_GET_SIZE(chunks) == 0) { Py_DECREF(chunks); return data; } Py_DECREF(data); break; } if (!PyBytes_Check(data)) { Py_DECREF(chunks); Py_DECREF(data); PyErr_SetString(PyExc_TypeError, "read() should return bytes"); return NULL; } if (PyBytes_GET_SIZE(data) == 0) { /* EOF */ Py_DECREF(data); break; } r = PyList_Append(chunks, data); Py_DECREF(data); if (r < 0) { Py_DECREF(chunks); return NULL; } } result = _PyBytes_Join(_PyIO_empty_bytes, chunks); Py_DECREF(chunks); return result; }
static int _Py_FatalError_PrintExc(int fd) { PyObject *ferr, *res; PyObject *exception, *v, *tb; int has_tb; if (PyThreadState_GET() == NULL) { /* The GIL is released: trying to acquire it is likely to deadlock, just give up. */ return 0; } PyErr_Fetch(&exception, &v, &tb); if (exception == NULL) { /* No current exception */ return 0; } ferr = _PySys_GetObjectId(&PyId_stderr); if (ferr == NULL || ferr == Py_None) { /* sys.stderr is not set yet or set to None, no need to try to display the exception */ return 0; } PyErr_NormalizeException(&exception, &v, &tb); if (tb == NULL) { tb = Py_None; Py_INCREF(tb); } PyException_SetTraceback(v, tb); if (exception == NULL) { /* PyErr_NormalizeException() failed */ return 0; } has_tb = (tb != Py_None); PyErr_Display(exception, v, tb); Py_XDECREF(exception); Py_XDECREF(v); Py_XDECREF(tb); /* sys.stderr may be buffered: call sys.stderr.flush() */ res = _PyObject_CallMethodId(ferr, &PyId_flush, ""); if (res == NULL) PyErr_Clear(); else Py_DECREF(res); return has_tb; }
static PyObject * zipimport_zipimporter_get_data_impl(ZipImporter *self, PyObject *path) /*[clinic end generated code: output=65dc506aaa268436 input=fa6428b74843c4ae]*/ { PyObject *key; PyObject *toc_entry; Py_ssize_t path_start, path_len, len; if (self->archive == NULL) { PyErr_SetString(PyExc_ValueError, "zipimporter.__init__() wasn't called"); return NULL; } #ifdef ALTSEP path = _PyObject_CallMethodId((PyObject *)&PyUnicode_Type, &PyId_replace, "OCC", path, ALTSEP, SEP); if (!path) return NULL; #else Py_INCREF(path); #endif if (PyUnicode_READY(path) == -1) goto error; path_len = PyUnicode_GET_LENGTH(path); len = PyUnicode_GET_LENGTH(self->archive); path_start = 0; if (PyUnicode_Tailmatch(path, self->archive, 0, len, -1) && PyUnicode_READ_CHAR(path, len) == SEP) { path_start = len + 1; } key = PyUnicode_Substring(path, path_start, path_len); if (key == NULL) goto error; toc_entry = PyDict_GetItem(self->files, key); if (toc_entry == NULL) { PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, key); Py_DECREF(key); goto error; } Py_DECREF(key); Py_DECREF(path); return get_data(self->archive, toc_entry); error: Py_DECREF(path); return NULL; }
static PyObject * time_strptime(PyObject *self, PyObject *args) { PyObject *strptime_module = PyImport_ImportModuleNoBlock("_strptime"); PyObject *strptime_result; _Py_IDENTIFIER(_strptime_time); if (!strptime_module) return NULL; strptime_result = _PyObject_CallMethodId(strptime_module, &PyId__strptime_time, "O", args); Py_DECREF(strptime_module); return strptime_result; }
static PyObject * _io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint) /*[clinic end generated code: output=2f50421677fa3dea input=1961c4a95e96e661]*/ { Py_ssize_t length = 0; PyObject *result; result = PyList_New(0); if (result == NULL) return NULL; if (hint <= 0) { /* XXX special-casing this made sense in the Python version in order to remove the bytecode interpretation overhead, but it could probably be removed here. */ _Py_IDENTIFIER(extend); PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self); if (ret == NULL) { Py_DECREF(result); return NULL; } Py_DECREF(ret); return result; } while (1) { PyObject *line = PyIter_Next(self); if (line == NULL) { if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } else break; /* StopIteration raised */ } if (PyList_Append(result, line) < 0) { Py_DECREF(line); Py_DECREF(result); return NULL; } length += PyObject_Size(line); Py_DECREF(line); if (length > hint) break; } return result; }
static PyObject * zipimporter_get_data(PyObject *obj, PyObject *args) { ZipImporter *self = (ZipImporter *)obj; PyObject *path, *key; #ifdef ALTSEP _Py_IDENTIFIER(replace); #endif PyObject *toc_entry; Py_ssize_t path_start, path_len, len; if (!PyArg_ParseTuple(args, "U:zipimporter.get_data", &path)) return NULL; #ifdef ALTSEP path = _PyObject_CallMethodId(path, &PyId_replace, "CC", ALTSEP, SEP); if (!path) return NULL; #else Py_INCREF(path); #endif if (PyUnicode_READY(path) == -1) goto error; path_len = PyUnicode_GET_LENGTH(path); len = PyUnicode_GET_LENGTH(self->archive); path_start = 0; if (PyUnicode_Tailmatch(path, self->archive, 0, len, -1) && PyUnicode_READ_CHAR(path, len) == SEP) { path_start = len + 1; } key = PyUnicode_Substring(path, path_start, path_len); if (key == NULL) goto error; toc_entry = PyDict_GetItem(self->files, key); if (toc_entry == NULL) { PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, key); Py_DECREF(key); goto error; } Py_DECREF(key); Py_DECREF(path); return get_data(self->archive, toc_entry); error: Py_DECREF(path); return NULL; }
static int fp_setreadl(struct tok_state *tok, const char* enc) { PyObject *readline = NULL, *stream = NULL, *io = NULL; _Py_IDENTIFIER(open); _Py_IDENTIFIER(readline); int fd; long pos; io = PyImport_ImportModuleNoBlock("io"); if (io == NULL) goto cleanup; fd = fileno(tok->fp); /* Due to buffering the file offset for fd can be different from the file * position of tok->fp. If tok->fp was opened in text mode on Windows, * its file position counts CRLF as one char and can't be directly mapped * to the file offset for fd. Instead we step back one byte and read to * the end of line.*/ pos = ftell(tok->fp); if (pos == -1 || lseek(fd, (off_t)(pos > 0 ? pos - 1 : pos), SEEK_SET) == (off_t)-1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, NULL); goto cleanup; } stream = _PyObject_CallMethodId(io, &PyId_open, "isisOOO", fd, "r", -1, enc, Py_None, Py_None, Py_False); if (stream == NULL) goto cleanup; Py_XDECREF(tok->decoding_readline); readline = _PyObject_GetAttrId(stream, &PyId_readline); tok->decoding_readline = readline; if (pos > 0) { if (PyObject_CallObject(readline, NULL) == NULL) { readline = NULL; goto cleanup; } } cleanup: Py_XDECREF(stream); Py_XDECREF(io); return readline != NULL; }
static int check_matched(PyObject *obj, PyObject *arg) { PyObject *result; _Py_IDENTIFIER(match); int rc; if (obj == Py_None) return 1; result = _PyObject_CallMethodId(obj, &PyId_match, "O", arg); if (result == NULL) return -1; rc = PyObject_IsTrue(result); Py_DECREF(result); return rc; }
PyObject * PyFile_FromFd(int fd, const char *name, const char *mode, int buffering, const char *encoding, const char *errors, const char *newline, int closefd) { PyObject *io, *stream; _Py_IDENTIFIER(open); io = PyImport_ImportModule("io"); if (io == NULL) return NULL; stream = _PyObject_CallMethodId(io, &PyId_open, "isisssi", fd, mode, buffering, encoding, errors, newline, closefd); Py_DECREF(io); if (stream == NULL) return NULL; /* ignore name attribute because the name attribute of _BufferedIOMixin and TextIOWrapper is read only */ return stream; }
static FNFCIGETNEXTCABINET(cb_getnextcabinet) { if (pv) { _Py_IDENTIFIER(getnextcabinet); PyObject *result = _PyObject_CallMethodId(pv, &PyId_getnextcabinet, "i", pccab->iCab); if (result == NULL) return -1; if (!PyBytes_Check(result)) { PyErr_Format(PyExc_TypeError, "Incorrect return type %s from getnextcabinet", result->ob_type->tp_name); Py_DECREF(result); return FALSE; } strncpy(pccab->szCab, PyBytes_AsString(result), sizeof(pccab->szCab)); return TRUE; } return FALSE; }
/* If gc was disabled, call gc.enable(). Return 0 on success. */ static int _enable_gc(int need_to_reenable_gc, PyObject *gc_module) { PyObject *result; _Py_IDENTIFIER(enable); PyObject *exctype, *val, *tb; if (need_to_reenable_gc) { PyErr_Fetch(&exctype, &val, &tb); result = _PyObject_CallMethodId(gc_module, &PyId_enable, NULL); if (exctype != NULL) { PyErr_Restore(exctype, val, tb); } if (result == NULL) { return 1; } Py_DECREF(result); } return 0; }
static PyObject * rawiobase_read(PyObject *self, PyObject *args) { Py_ssize_t n = -1; PyObject *b, *res; if (!PyArg_ParseTuple(args, "|n:read", &n)) { return NULL; } if (n < 0) { _Py_IDENTIFIER(readall); return _PyObject_CallMethodId(self, &PyId_readall, NULL); } /* TODO: allocate a bytes object directly instead and manually construct a writable memoryview pointing to it. */ b = PyByteArray_FromStringAndSize(NULL, n); if (b == NULL) return NULL; res = PyObject_CallMethodObjArgs(self, _PyIO_str_readinto, b, NULL); if (res == NULL || res == Py_None) { Py_DECREF(b); return res; } n = PyNumber_AsSsize_t(res, PyExc_ValueError); Py_DECREF(res); if (n == -1 && PyErr_Occurred()) { Py_DECREF(b); return NULL; } res = PyBytes_FromStringAndSize(PyByteArray_AsString(b), n); Py_DECREF(b); return res; }
/* Wait until threading._shutdown completes, provided the threading module was imported in the first place. The shutdown routine will wait until all non-daemon "threading" threads have completed. */ static void wait_for_thread_shutdown(void) { #ifdef WITH_THREAD _Py_IDENTIFIER(_shutdown); PyObject *result; PyThreadState *tstate = PyThreadState_GET(); PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, "threading"); if (threading == NULL) { /* threading not imported */ PyErr_Clear(); return; } result = _PyObject_CallMethodId(threading, &PyId__shutdown, ""); if (result == NULL) { PyErr_WriteUnraisable(threading); } else { Py_DECREF(result); } Py_DECREF(threading); #endif }
static PyObject * subprocess_fork_exec(PyObject* self, PyObject *args) { PyObject *gc_module = NULL; PyObject *executable_list, *py_fds_to_keep; PyObject *env_list, *preexec_fn; PyObject *process_args, *converted_args = NULL, *fast_args = NULL; PyObject *preexec_fn_args_tuple = NULL; int p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite; int errpipe_read, errpipe_write, close_fds, restore_signals; int call_setsid; PyObject *cwd_obj, *cwd_obj2; const char *cwd; pid_t pid; int need_to_reenable_gc = 0; char *const *exec_array, *const *argv = NULL, *const *envp = NULL; Py_ssize_t arg_num; if (!PyArg_ParseTuple( args, "OOpOOOiiiiiiiiiiO:fork_exec", &process_args, &executable_list, &close_fds, &py_fds_to_keep, &cwd_obj, &env_list, &p2cread, &p2cwrite, &c2pread, &c2pwrite, &errread, &errwrite, &errpipe_read, &errpipe_write, &restore_signals, &call_setsid, &preexec_fn)) return NULL; if (close_fds && errpipe_write < 3) { /* precondition */ PyErr_SetString(PyExc_ValueError, "errpipe_write must be >= 3"); return NULL; } if (PySequence_Length(py_fds_to_keep) < 0) { PyErr_SetString(PyExc_ValueError, "cannot get length of fds_to_keep"); return NULL; } if (_sanity_check_python_fd_sequence(py_fds_to_keep)) { PyErr_SetString(PyExc_ValueError, "bad value(s) in fds_to_keep"); return NULL; } /* We need to call gc.disable() when we'll be calling preexec_fn */ if (preexec_fn != Py_None) { PyObject *result; _Py_IDENTIFIER(isenabled); _Py_IDENTIFIER(disable); gc_module = PyImport_ImportModule("gc"); if (gc_module == NULL) return NULL; result = _PyObject_CallMethodId(gc_module, &PyId_isenabled, NULL); if (result == NULL) { Py_DECREF(gc_module); return NULL; } need_to_reenable_gc = PyObject_IsTrue(result); Py_DECREF(result); if (need_to_reenable_gc == -1) { Py_DECREF(gc_module); return NULL; } result = _PyObject_CallMethodId(gc_module, &PyId_disable, NULL); if (result == NULL) { Py_DECREF(gc_module); return NULL; } Py_DECREF(result); } exec_array = _PySequence_BytesToCharpArray(executable_list); if (!exec_array) { Py_XDECREF(gc_module); return NULL; } /* Convert args and env into appropriate arguments for exec() */ /* These conversions are done in the parent process to avoid allocating or freeing memory in the child process. */ if (process_args != Py_None) { Py_ssize_t num_args; /* Equivalent to: */ /* tuple(PyUnicode_FSConverter(arg) for arg in process_args) */ fast_args = PySequence_Fast(process_args, "argv must be a tuple"); if (fast_args == NULL) goto cleanup; num_args = PySequence_Fast_GET_SIZE(fast_args); converted_args = PyTuple_New(num_args); if (converted_args == NULL) goto cleanup; for (arg_num = 0; arg_num < num_args; ++arg_num) { PyObject *borrowed_arg, *converted_arg; borrowed_arg = PySequence_Fast_GET_ITEM(fast_args, arg_num); if (PyUnicode_FSConverter(borrowed_arg, &converted_arg) == 0) goto cleanup; PyTuple_SET_ITEM(converted_args, arg_num, converted_arg); } argv = _PySequence_BytesToCharpArray(converted_args); Py_CLEAR(converted_args); Py_CLEAR(fast_args); if (!argv) goto cleanup; } if (env_list != Py_None) { envp = _PySequence_BytesToCharpArray(env_list); if (!envp) goto cleanup; } if (preexec_fn != Py_None) { preexec_fn_args_tuple = PyTuple_New(0); if (!preexec_fn_args_tuple) goto cleanup; _PyImport_AcquireLock(); } if (cwd_obj != Py_None) { if (PyUnicode_FSConverter(cwd_obj, &cwd_obj2) == 0) goto cleanup; cwd = PyBytes_AsString(cwd_obj2); } else { cwd = NULL; cwd_obj2 = NULL; } pid = fork(); if (pid == 0) { /* Child process */ /* * Code from here to _exit() must only use async-signal-safe functions, * listed at `man 7 signal` or * http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html. */ if (preexec_fn != Py_None) { /* We'll be calling back into Python later so we need to do this. * This call may not be async-signal-safe but neither is calling * back into Python. The user asked us to use hope as a strategy * to avoid deadlock... */ PyOS_AfterFork(); } child_exec(exec_array, argv, envp, cwd, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, errpipe_read, errpipe_write, close_fds, restore_signals, call_setsid, py_fds_to_keep, preexec_fn, preexec_fn_args_tuple); _exit(255); return NULL; /* Dead code to avoid a potential compiler warning. */ } Py_XDECREF(cwd_obj2); if (pid == -1) { /* Capture the errno exception before errno can be clobbered. */ PyErr_SetFromErrno(PyExc_OSError); } if (preexec_fn != Py_None && _PyImport_ReleaseLock() < 0 && !PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError, "not holding the import lock"); } /* Parent process */ if (envp) _Py_FreeCharPArray(envp); if (argv) _Py_FreeCharPArray(argv); _Py_FreeCharPArray(exec_array); /* Reenable gc in the parent process (or if fork failed). */ if (need_to_reenable_gc && _enable_gc(gc_module)) { Py_XDECREF(gc_module); return NULL; } Py_XDECREF(preexec_fn_args_tuple); Py_XDECREF(gc_module); if (pid == -1) return NULL; /* fork() failed. Exception set earlier. */ return PyLong_FromPid(pid); cleanup: if (envp) _Py_FreeCharPArray(envp); if (argv) _Py_FreeCharPArray(argv); _Py_FreeCharPArray(exec_array); Py_XDECREF(converted_args); Py_XDECREF(fast_args); Py_XDECREF(preexec_fn_args_tuple); /* Reenable gc if it was disabled. */ if (need_to_reenable_gc) _enable_gc(gc_module); Py_XDECREF(gc_module); return NULL; }
static PyObject * _Py_FindSourceFile(PyObject *filename, char* namebuf, size_t namelen, PyObject *io) { Py_ssize_t i; PyObject *binary; PyObject *v; Py_ssize_t npath; size_t taillen; PyObject *syspath; PyObject *path; const char* tail; PyObject *filebytes; const char* filepath; Py_ssize_t len; PyObject* result; filebytes = PyUnicode_EncodeFSDefault(filename); if (filebytes == NULL) { PyErr_Clear(); return NULL; } filepath = PyBytes_AS_STRING(filebytes); /* Search tail of filename in sys.path before giving up */ tail = strrchr(filepath, SEP); if (tail == NULL) tail = filepath; else tail++; taillen = strlen(tail); syspath = _PySys_GetObjectId(&PyId_path); if (syspath == NULL || !PyList_Check(syspath)) goto error; npath = PyList_Size(syspath); for (i = 0; i < npath; i++) { v = PyList_GetItem(syspath, i); if (v == NULL) { PyErr_Clear(); break; } if (!PyUnicode_Check(v)) continue; path = PyUnicode_EncodeFSDefault(v); if (path == NULL) { PyErr_Clear(); continue; } len = PyBytes_GET_SIZE(path); if (len + 1 + (Py_ssize_t)taillen >= (Py_ssize_t)namelen - 1) { Py_DECREF(path); continue; /* Too long */ } strcpy(namebuf, PyBytes_AS_STRING(path)); Py_DECREF(path); if (strlen(namebuf) != (size_t)len) continue; /* v contains '\0' */ if (len > 0 && namebuf[len-1] != SEP) namebuf[len++] = SEP; strcpy(namebuf+len, tail); binary = _PyObject_CallMethodId(io, &PyId_open, "ss", namebuf, "rb"); if (binary != NULL) { result = binary; goto finally; } PyErr_Clear(); } goto error; error: result = NULL; finally: Py_DECREF(filebytes); return result; }
int _Py_DisplaySourceLine(PyObject *f, PyObject *filename, int lineno, int indent) { int err = 0; int fd; int i; char *found_encoding; char *encoding; PyObject *io; PyObject *binary; PyObject *fob = NULL; PyObject *lineobj = NULL; PyObject *res; char buf[MAXPATHLEN+1]; int kind; void *data; /* open the file */ if (filename == NULL) return 0; io = PyImport_ImportModuleNoBlock("io"); if (io == NULL) return -1; binary = _PyObject_CallMethodId(io, &PyId_open, "Os", filename, "rb"); if (binary == NULL) { PyErr_Clear(); binary = _Py_FindSourceFile(filename, buf, sizeof(buf), io); if (binary == NULL) { Py_DECREF(io); return -1; } } /* use the right encoding to decode the file as unicode */ fd = PyObject_AsFileDescriptor(binary); if (fd < 0) { Py_DECREF(io); Py_DECREF(binary); return 0; } found_encoding = PyTokenizer_FindEncodingFilename(fd, filename); if (found_encoding == NULL) PyErr_Clear(); encoding = (found_encoding != NULL) ? found_encoding : "utf-8"; /* Reset position */ if (lseek(fd, 0, SEEK_SET) == (off_t)-1) { Py_DECREF(io); Py_DECREF(binary); PyMem_FREE(found_encoding); return 0; } fob = _PyObject_CallMethodId(io, &PyId_TextIOWrapper, "Os", binary, encoding); Py_DECREF(io); Py_DECREF(binary); PyMem_FREE(found_encoding); if (fob == NULL) { PyErr_Clear(); return 0; } /* get the line number lineno */ for (i = 0; i < lineno; i++) { Py_XDECREF(lineobj); lineobj = PyFile_GetLine(fob, -1); if (!lineobj) { err = -1; break; } } res = _PyObject_CallMethodId(fob, &PyId_close, ""); if (res) Py_DECREF(res); else PyErr_Clear(); Py_DECREF(fob); if (!lineobj || !PyUnicode_Check(lineobj)) { Py_XDECREF(lineobj); return err; } /* remove the indentation of the line */ kind = PyUnicode_KIND(lineobj); data = PyUnicode_DATA(lineobj); for (i=0; i < PyUnicode_GET_LENGTH(lineobj); i++) { Py_UCS4 ch = PyUnicode_READ(kind, data, i); if (ch != ' ' && ch != '\t' && ch != '\014') break; } if (i) { PyObject *truncated; truncated = PyUnicode_Substring(lineobj, i, PyUnicode_GET_LENGTH(lineobj)); if (truncated) { Py_DECREF(lineobj); lineobj = truncated; } else { PyErr_Clear(); } } /* Write some spaces before the line */ strcpy(buf, " "); assert (strlen(buf) == 10); while (indent > 0) { if (indent < 10) buf[indent] = '\0'; err = PyFile_WriteString(buf, f); if (err != 0) break; indent -= 10; } /* finally display the line */ if (err == 0) err = PyFile_WriteObject(lineobj, f, Py_PRINT_RAW); Py_DECREF(lineobj); if (err == 0) err = PyFile_WriteString("\n", f); return err; }