| /* Readline interface for tokenizer.c and [raw_]input() in bltinmodule.c. | |
| By default, or when stdin is not a tty device, we have a super | |
| simple my_readline function using fgets. | |
| Optionally, we can use the GNU readline library. | |
| my_readline() has a different return value from GNU readline(): | |
| - NULL if an interrupt occurred or if an error occurred | |
| - a malloc'ed empty string if EOF was read | |
| - a malloc'ed string ending in \n normally | |
| */ | |
| #include "Python.h" | |
| #include "internal/pystate.h" | |
| #ifdef MS_WINDOWS | |
| #define WIN32_LEAN_AND_MEAN | |
| #include "windows.h" | |
| #endif /* MS_WINDOWS */ | |
| PyThreadState* _PyOS_ReadlineTState = NULL; | |
| #include "pythread.h" | |
| static PyThread_type_lock _PyOS_ReadlineLock = NULL; | |
| int (*PyOS_InputHook)(void) = NULL; | |
| /* This function restarts a fgets() after an EINTR error occurred | |
| except if PyOS_InterruptOccurred() returns true. */ | |
| static int | |
| my_fgets(char *buf, int len, FILE *fp) | |
| { | |
| #ifdef MS_WINDOWS | |
| HANDLE hInterruptEvent; | |
| #endif | |
| char *p; | |
| int err; | |
| while (1) { | |
| if (PyOS_InputHook != NULL) | |
| (void)(PyOS_InputHook)(); | |
| errno = 0; | |
| clearerr(fp); | |
| p = fgets(buf, len, fp); | |
| if (p != NULL) | |
| return 0; /* No error */ | |
| err = errno; | |
| #ifdef MS_WINDOWS | |
| /* Ctrl-C anywhere on the line or Ctrl-Z if the only character | |
| on a line will set ERROR_OPERATION_ABORTED. Under normal | |
| circumstances Ctrl-C will also have caused the SIGINT handler | |
| to fire which will have set the event object returned by | |
| _PyOS_SigintEvent. This signal fires in another thread and | |
| is not guaranteed to have occurred before this point in the | |
| code. | |
| Therefore: check whether the event is set with a small timeout. | |
| If it is, assume this is a Ctrl-C and reset the event. If it | |
| isn't set assume that this is a Ctrl-Z on its own and drop | |
| through to check for EOF. | |
| */ | |
| if (GetLastError()==ERROR_OPERATION_ABORTED) { | |
| hInterruptEvent = _PyOS_SigintEvent(); | |
| switch (WaitForSingleObjectEx(hInterruptEvent, 10, FALSE)) { | |
| case WAIT_OBJECT_0: | |
| ResetEvent(hInterruptEvent); | |
| return 1; /* Interrupt */ | |
| case WAIT_FAILED: | |
| return -2; /* Error */ | |
| } | |
| } | |
| #endif /* MS_WINDOWS */ | |
| if (feof(fp)) { | |
| clearerr(fp); | |
| return -1; /* EOF */ | |
| } | |
| #ifdef EINTR | |
| if (err == EINTR) { | |
| int s; | |
| PyEval_RestoreThread(_PyOS_ReadlineTState); | |
| s = PyErr_CheckSignals(); | |
| PyEval_SaveThread(); | |
| if (s < 0) | |
| return 1; | |
| /* try again */ | |
| continue; | |
| } | |
| #endif | |
| if (PyOS_InterruptOccurred()) { | |
| return 1; /* Interrupt */ | |
| } | |
| return -2; /* Error */ | |
| } | |
| /* NOTREACHED */ | |
| } | |
| #ifdef MS_WINDOWS | |
| /* Readline implementation using ReadConsoleW */ | |
| extern char _get_console_type(HANDLE handle); | |
| char * | |
| _PyOS_WindowsConsoleReadline(HANDLE hStdIn) | |
| { | |
| static wchar_t wbuf_local[1024 * 16]; | |
| const DWORD chunk_size = 1024; | |
| DWORD n_read, total_read, wbuflen, u8len; | |
| wchar_t *wbuf; | |
| char *buf = NULL; | |
| int err = 0; | |
| n_read = (DWORD)-1; | |
| total_read = 0; | |
| wbuf = wbuf_local; | |
| wbuflen = sizeof(wbuf_local) / sizeof(wbuf_local[0]) - 1; | |
| while (1) { | |
| if (PyOS_InputHook != NULL) { | |
| (void)(PyOS_InputHook)(); | |
| } | |
| if (!ReadConsoleW(hStdIn, &wbuf[total_read], wbuflen - total_read, &n_read, NULL)) { | |
| err = GetLastError(); | |
| goto exit; | |
| } | |
| if (n_read == (DWORD)-1 && (err = GetLastError()) == ERROR_OPERATION_ABORTED) { | |
| break; | |
| } | |
| if (n_read == 0) { | |
| int s; | |
| err = GetLastError(); | |
| if (err != ERROR_OPERATION_ABORTED) | |
| goto exit; | |
| err = 0; | |
| HANDLE hInterruptEvent = _PyOS_SigintEvent(); | |
| if (WaitForSingleObjectEx(hInterruptEvent, 100, FALSE) | |
| == WAIT_OBJECT_0) { | |
| ResetEvent(hInterruptEvent); | |
| PyEval_RestoreThread(_PyOS_ReadlineTState); | |
| s = PyErr_CheckSignals(); | |
| PyEval_SaveThread(); | |
| if (s < 0) | |
| goto exit; | |
| } | |
| break; | |
| } | |
| total_read += n_read; | |
| if (total_read == 0 || wbuf[total_read - 1] == L'\n') { | |
| break; | |
| } | |
| wbuflen += chunk_size; | |
| if (wbuf == wbuf_local) { | |
| wbuf[total_read] = '\0'; | |
| wbuf = (wchar_t*)PyMem_RawMalloc(wbuflen * sizeof(wchar_t)); | |
| if (wbuf) | |
| wcscpy_s(wbuf, wbuflen, wbuf_local); | |
| else { | |
| PyErr_NoMemory(); | |
| goto exit; | |
| } | |
| } | |
| else { | |
| wchar_t *tmp = PyMem_RawRealloc(wbuf, wbuflen * sizeof(wchar_t)); | |
| if (tmp == NULL) { | |
| PyErr_NoMemory(); | |
| goto exit; | |
| } | |
| wbuf = tmp; | |
| } | |
| } | |
| if (wbuf[0] == '\x1a') { | |
| buf = PyMem_RawMalloc(1); | |
| if (buf) | |
| buf[0] = '\0'; | |
| else { | |
| PyErr_NoMemory(); | |
| } | |
| goto exit; | |
| } | |
| u8len = WideCharToMultiByte(CP_UTF8, 0, wbuf, total_read, NULL, 0, NULL, NULL); | |
| buf = PyMem_RawMalloc(u8len + 1); | |
| if (buf == NULL) { | |
| PyErr_NoMemory(); | |
| goto exit; | |
| } | |
| u8len = WideCharToMultiByte(CP_UTF8, 0, wbuf, total_read, buf, u8len, NULL, NULL); | |
| buf[u8len] = '\0'; | |
| exit: | |
| if (wbuf != wbuf_local) | |
| PyMem_RawFree(wbuf); | |
| if (err) { | |
| PyEval_RestoreThread(_PyOS_ReadlineTState); | |
| PyErr_SetFromWindowsErr(err); | |
| PyEval_SaveThread(); | |
| } | |
| return buf; | |
| } | |
| #endif | |
| /* Readline implementation using fgets() */ | |
| char * | |
| PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) | |
| { | |
| size_t n; | |
| char *p, *pr; | |
| #ifdef MS_WINDOWS | |
| if (!Py_LegacyWindowsStdioFlag && sys_stdin == stdin) { | |
| HANDLE hStdIn, hStdErr; | |
| _Py_BEGIN_SUPPRESS_IPH | |
| hStdIn = (HANDLE)_get_osfhandle(fileno(sys_stdin)); | |
| hStdErr = (HANDLE)_get_osfhandle(fileno(stderr)); | |
| _Py_END_SUPPRESS_IPH | |
| if (_get_console_type(hStdIn) == 'r') { | |
| fflush(sys_stdout); | |
| if (prompt) { | |
| if (_get_console_type(hStdErr) == 'w') { | |
| wchar_t *wbuf; | |
| int wlen; | |
| wlen = MultiByteToWideChar(CP_UTF8, 0, prompt, -1, | |
| NULL, 0); | |
| if (wlen) { | |
| wbuf = PyMem_RawMalloc(wlen * sizeof(wchar_t)); | |
| if (wbuf == NULL) { | |
| PyErr_NoMemory(); | |
| return NULL; | |
| } | |
| wlen = MultiByteToWideChar(CP_UTF8, 0, prompt, -1, | |
| wbuf, wlen); | |
| if (wlen) { | |
| DWORD n; | |
| fflush(stderr); | |
| /* wlen includes null terminator, so subtract 1 */ | |
| WriteConsoleW(hStdErr, wbuf, wlen - 1, &n, NULL); | |
| } | |
| PyMem_RawFree(wbuf); | |
| } | |
| } else { | |
| fprintf(stderr, "%s", prompt); | |
| fflush(stderr); | |
| } | |
| } | |
| clearerr(sys_stdin); | |
| return _PyOS_WindowsConsoleReadline(hStdIn); | |
| } | |
| } | |
| #endif | |
| n = 100; | |
| p = (char *)PyMem_RawMalloc(n); | |
| if (p == NULL) { | |
| PyErr_NoMemory(); | |
| return NULL; | |
| } | |
| fflush(sys_stdout); | |
| if (prompt) | |
| fprintf(stderr, "%s", prompt); | |
| fflush(stderr); | |
| switch (my_fgets(p, (int)n, sys_stdin)) { | |
| case 0: /* Normal case */ | |
| break; | |
| case 1: /* Interrupt */ | |
| PyMem_RawFree(p); | |
| return NULL; | |
| case -1: /* EOF */ | |
| case -2: /* Error */ | |
| default: /* Shouldn't happen */ | |
| *p = '\0'; | |
| break; | |
| } | |
| n = strlen(p); | |
| while (n > 0 && p[n-1] != '\n') { | |
| size_t incr = n+2; | |
| if (incr > INT_MAX) { | |
| PyMem_RawFree(p); | |
| PyErr_SetString(PyExc_OverflowError, "input line too long"); | |
| return NULL; | |
| } | |
| pr = (char *)PyMem_RawRealloc(p, n + incr); | |
| if (pr == NULL) { | |
| PyMem_RawFree(p); | |
| PyErr_NoMemory(); | |
| return NULL; | |
| } | |
| p = pr; | |
| if (my_fgets(p+n, (int)incr, sys_stdin) != 0) | |
| break; | |
| n += strlen(p+n); | |
| } | |
| pr = (char *)PyMem_RawRealloc(p, n+1); | |
| if (pr == NULL) { | |
| PyMem_RawFree(p); | |
| PyErr_NoMemory(); | |
| return NULL; | |
| } | |
| return pr; | |
| } | |
| /* By initializing this function pointer, systems embedding Python can | |
| override the readline function. | |
| Note: Python expects in return a buffer allocated with PyMem_Malloc. */ | |
| char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *) = NULL; | |
| /* Interface used by tokenizer.c and bltinmodule.c */ | |
| char * | |
| PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) | |
| { | |
| char *rv, *res; | |
| size_t len; | |
| if (_PyOS_ReadlineTState == PyThreadState_GET()) { | |
| PyErr_SetString(PyExc_RuntimeError, | |
| "can't re-enter readline"); | |
| return NULL; | |
| } | |
| if (PyOS_ReadlineFunctionPointer == NULL) { | |
| PyOS_ReadlineFunctionPointer = PyOS_StdioReadline; | |
| } | |
| if (_PyOS_ReadlineLock == NULL) { | |
| _PyOS_ReadlineLock = PyThread_allocate_lock(); | |
| if (_PyOS_ReadlineLock == NULL) { | |
| PyErr_SetString(PyExc_MemoryError, "can't allocate lock"); | |
| return NULL; | |
| } | |
| } | |
| _PyOS_ReadlineTState = PyThreadState_GET(); | |
| Py_BEGIN_ALLOW_THREADS | |
| PyThread_acquire_lock(_PyOS_ReadlineLock, 1); | |
| /* This is needed to handle the unlikely case that the | |
| * interpreter is in interactive mode *and* stdin/out are not | |
| * a tty. This can happen, for example if python is run like | |
| * this: python -i < test1.py | |
| */ | |
| if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout))) | |
| rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt); | |
| else | |
| rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout, | |
| prompt); | |
| Py_END_ALLOW_THREADS | |
| PyThread_release_lock(_PyOS_ReadlineLock); | |
| _PyOS_ReadlineTState = NULL; | |
| if (rv == NULL) | |
| return NULL; | |
| len = strlen(rv) + 1; | |
| res = PyMem_Malloc(len); | |
| if (res != NULL) { | |
| memcpy(res, rv, len); | |
| } | |
| else { | |
| PyErr_NoMemory(); | |
| } | |
| PyMem_RawFree(rv); | |
| return res; | |
| } |