Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 1 | |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 2 | /* Readline interface for tokenizer.c and [raw_]input() in bltinmodule.c. |
| 3 | By default, or when stdin is not a tty device, we have a super |
| 4 | simple my_readline function using fgets. |
| 5 | Optionally, we can use the GNU readline library. |
Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 6 | my_readline() has a different return value from GNU readline(): |
| 7 | - NULL if an interrupt occurred or if an error occurred |
| 8 | - a malloc'ed empty string if EOF was read |
| 9 | - a malloc'ed string ending in \n normally |
| 10 | */ |
| 11 | |
Guido van Rossum | 8efa47b | 1998-08-27 19:43:43 +0000 | [diff] [blame] | 12 | #include "Python.h" |
Eric Snow | 2ebc5ce | 2017-09-07 23:51:28 -0600 | [diff] [blame] | 13 | #include "internal/pystate.h" |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 14 | #ifdef MS_WINDOWS |
| 15 | #define WIN32_LEAN_AND_MEAN |
| 16 | #include "windows.h" |
| 17 | #endif /* MS_WINDOWS */ |
Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 18 | |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 19 | |
| 20 | PyThreadState* _PyOS_ReadlineTState; |
| 21 | |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 22 | #include "pythread.h" |
| 23 | static PyThread_type_lock _PyOS_ReadlineLock = NULL; |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 24 | |
Thomas Wouters | 23c9e00 | 2000-07-22 19:20:54 +0000 | [diff] [blame] | 25 | int (*PyOS_InputHook)(void) = NULL; |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 26 | |
| 27 | /* This function restarts a fgets() after an EINTR error occurred |
| 28 | except if PyOS_InterruptOccurred() returns true. */ |
| 29 | |
| 30 | static int |
Thomas Wouters | 23c9e00 | 2000-07-22 19:20:54 +0000 | [diff] [blame] | 31 | my_fgets(char *buf, int len, FILE *fp) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 32 | { |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 33 | #ifdef MS_WINDOWS |
| 34 | HANDLE hInterruptEvent; |
| 35 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 36 | char *p; |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 37 | int err; |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 38 | while (1) { |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 39 | if (PyOS_InputHook != NULL) |
| 40 | (void)(PyOS_InputHook)(); |
| 41 | errno = 0; |
Victor Stinner | 4f71101 | 2011-05-30 23:46:00 +0200 | [diff] [blame] | 42 | clearerr(fp); |
Steve Dower | 940f33a | 2016-09-08 11:21:54 -0700 | [diff] [blame] | 43 | p = fgets(buf, len, fp); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 44 | if (p != NULL) |
| 45 | return 0; /* No error */ |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 46 | err = errno; |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 47 | #ifdef MS_WINDOWS |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 48 | /* Ctrl-C anywhere on the line or Ctrl-Z if the only character |
| 49 | on a line will set ERROR_OPERATION_ABORTED. Under normal |
| 50 | circumstances Ctrl-C will also have caused the SIGINT handler |
| 51 | to fire which will have set the event object returned by |
| 52 | _PyOS_SigintEvent. This signal fires in another thread and |
| 53 | is not guaranteed to have occurred before this point in the |
| 54 | code. |
| 55 | |
| 56 | Therefore: check whether the event is set with a small timeout. |
| 57 | If it is, assume this is a Ctrl-C and reset the event. If it |
| 58 | isn't set assume that this is a Ctrl-Z on its own and drop |
| 59 | through to check for EOF. |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 60 | */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 61 | if (GetLastError()==ERROR_OPERATION_ABORTED) { |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 62 | hInterruptEvent = _PyOS_SigintEvent(); |
Martin v. Löwis | b26a9b1 | 2013-01-25 14:25:48 +0100 | [diff] [blame] | 63 | switch (WaitForSingleObjectEx(hInterruptEvent, 10, FALSE)) { |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 64 | case WAIT_OBJECT_0: |
| 65 | ResetEvent(hInterruptEvent); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 66 | return 1; /* Interrupt */ |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 67 | case WAIT_FAILED: |
| 68 | return -2; /* Error */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 69 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 70 | } |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 71 | #endif /* MS_WINDOWS */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 72 | if (feof(fp)) { |
Victor Stinner | 4755ab0 | 2011-05-10 00:19:53 +0200 | [diff] [blame] | 73 | clearerr(fp); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 74 | return -1; /* EOF */ |
| 75 | } |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 76 | #ifdef EINTR |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 77 | if (err == EINTR) { |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 78 | int s; |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 79 | PyEval_RestoreThread(_PyOS_ReadlineTState); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 80 | s = PyErr_CheckSignals(); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 81 | PyEval_SaveThread(); |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 82 | if (s < 0) |
| 83 | return 1; |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 84 | /* try again */ |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 85 | continue; |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 86 | } |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 87 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 88 | if (PyOS_InterruptOccurred()) { |
| 89 | return 1; /* Interrupt */ |
| 90 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 91 | return -2; /* Error */ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 92 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 93 | /* NOTREACHED */ |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 94 | } |
| 95 | |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 96 | #ifdef MS_WINDOWS |
| 97 | /* Readline implementation using ReadConsoleW */ |
| 98 | |
| 99 | extern char _get_console_type(HANDLE handle); |
| 100 | |
| 101 | char * |
| 102 | _PyOS_WindowsConsoleReadline(HANDLE hStdIn) |
| 103 | { |
| 104 | static wchar_t wbuf_local[1024 * 16]; |
| 105 | const DWORD chunk_size = 1024; |
| 106 | |
| 107 | DWORD n_read, total_read, wbuflen, u8len; |
| 108 | wchar_t *wbuf; |
| 109 | char *buf = NULL; |
| 110 | int err = 0; |
| 111 | |
| 112 | n_read = 0; |
| 113 | total_read = 0; |
| 114 | wbuf = wbuf_local; |
| 115 | wbuflen = sizeof(wbuf_local) / sizeof(wbuf_local[0]) - 1; |
| 116 | while (1) { |
| 117 | if (!ReadConsoleW(hStdIn, &wbuf[total_read], wbuflen - total_read, &n_read, NULL)) { |
| 118 | err = GetLastError(); |
| 119 | goto exit; |
| 120 | } |
| 121 | if (n_read == 0) { |
| 122 | int s; |
| 123 | err = GetLastError(); |
| 124 | if (err != ERROR_OPERATION_ABORTED) |
| 125 | goto exit; |
| 126 | err = 0; |
| 127 | HANDLE hInterruptEvent = _PyOS_SigintEvent(); |
| 128 | if (WaitForSingleObjectEx(hInterruptEvent, 100, FALSE) |
| 129 | == WAIT_OBJECT_0) { |
| 130 | ResetEvent(hInterruptEvent); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 131 | PyEval_RestoreThread(_PyOS_ReadlineTState); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 132 | s = PyErr_CheckSignals(); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 133 | PyEval_SaveThread(); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 134 | if (s < 0) |
| 135 | goto exit; |
| 136 | } |
| 137 | break; |
| 138 | } |
| 139 | |
| 140 | total_read += n_read; |
| 141 | if (total_read == 0 || wbuf[total_read - 1] == L'\n') { |
| 142 | break; |
| 143 | } |
| 144 | wbuflen += chunk_size; |
| 145 | if (wbuf == wbuf_local) { |
| 146 | wbuf[total_read] = '\0'; |
| 147 | wbuf = (wchar_t*)PyMem_RawMalloc(wbuflen * sizeof(wchar_t)); |
| 148 | if (wbuf) |
| 149 | wcscpy_s(wbuf, wbuflen, wbuf_local); |
| 150 | } |
| 151 | else |
| 152 | wbuf = (wchar_t*)PyMem_RawRealloc(wbuf, wbuflen * sizeof(wchar_t)); |
| 153 | } |
| 154 | |
| 155 | if (wbuf[0] == '\x1a') { |
| 156 | buf = PyMem_RawMalloc(1); |
| 157 | if (buf) |
| 158 | buf[0] = '\0'; |
| 159 | goto exit; |
| 160 | } |
| 161 | |
| 162 | u8len = WideCharToMultiByte(CP_UTF8, 0, wbuf, total_read, NULL, 0, NULL, NULL); |
| 163 | buf = PyMem_RawMalloc(u8len + 1); |
| 164 | u8len = WideCharToMultiByte(CP_UTF8, 0, wbuf, total_read, buf, u8len, NULL, NULL); |
| 165 | buf[u8len] = '\0'; |
Benjamin Peterson | e2e792d | 2016-09-19 22:17:16 -0700 | [diff] [blame] | 166 | |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 167 | exit: |
| 168 | if (wbuf != wbuf_local) |
| 169 | PyMem_RawFree(wbuf); |
| 170 | |
| 171 | if (err) { |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 172 | PyEval_RestoreThread(_PyOS_ReadlineTState); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 173 | PyErr_SetFromWindowsErr(err); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 174 | PyEval_SaveThread(); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | return buf; |
| 178 | } |
| 179 | |
| 180 | #endif |
| 181 | |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 182 | |
| 183 | /* Readline implementation using fgets() */ |
| 184 | |
| 185 | char * |
Serhiy Storchaka | c679227 | 2013-10-19 21:03:34 +0300 | [diff] [blame] | 186 | PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 187 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 188 | size_t n; |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 189 | char *p, *pr; |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 190 | |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 191 | #ifdef MS_WINDOWS |
| 192 | if (!Py_LegacyWindowsStdioFlag && sys_stdin == stdin) { |
Steve Dower | 3cd187b | 2016-10-08 12:18:16 -0700 | [diff] [blame] | 193 | HANDLE hStdIn, hStdErr; |
Benjamin Peterson | e2e792d | 2016-09-19 22:17:16 -0700 | [diff] [blame] | 194 | |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 195 | _Py_BEGIN_SUPPRESS_IPH |
| 196 | hStdIn = (HANDLE)_get_osfhandle(fileno(sys_stdin)); |
Steve Dower | 3cd187b | 2016-10-08 12:18:16 -0700 | [diff] [blame] | 197 | hStdErr = (HANDLE)_get_osfhandle(fileno(stderr)); |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 198 | _Py_END_SUPPRESS_IPH |
Benjamin Peterson | e2e792d | 2016-09-19 22:17:16 -0700 | [diff] [blame] | 199 | |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 200 | if (_get_console_type(hStdIn) == 'r') { |
| 201 | fflush(sys_stdout); |
Steve Dower | 3cd187b | 2016-10-08 12:18:16 -0700 | [diff] [blame] | 202 | if (prompt) { |
| 203 | if (_get_console_type(hStdErr) == 'w') { |
| 204 | wchar_t *wbuf; |
| 205 | int wlen; |
| 206 | wlen = MultiByteToWideChar(CP_UTF8, 0, prompt, -1, |
| 207 | NULL, 0); |
Steve Dower | 59bd34f | 2016-10-08 12:20:45 -0700 | [diff] [blame] | 208 | if (wlen && |
Steve Dower | 3cd187b | 2016-10-08 12:18:16 -0700 | [diff] [blame] | 209 | (wbuf = PyMem_RawMalloc(wlen * sizeof(wchar_t)))) { |
| 210 | wlen = MultiByteToWideChar(CP_UTF8, 0, prompt, -1, |
| 211 | wbuf, wlen); |
| 212 | if (wlen) { |
| 213 | DWORD n; |
| 214 | fflush(stderr); |
Steve Dower | 6c2b9d3 | 2016-10-25 11:51:54 -0700 | [diff] [blame] | 215 | /* wlen includes null terminator, so subtract 1 */ |
| 216 | WriteConsoleW(hStdErr, wbuf, wlen - 1, &n, NULL); |
Steve Dower | 3cd187b | 2016-10-08 12:18:16 -0700 | [diff] [blame] | 217 | } |
| 218 | PyMem_RawFree(wbuf); |
| 219 | } |
| 220 | } else { |
| 221 | fprintf(stderr, "%s", prompt); |
| 222 | fflush(stderr); |
| 223 | } |
| 224 | } |
Steve Dower | 3929499 | 2016-08-30 21:22:36 -0700 | [diff] [blame] | 225 | clearerr(sys_stdin); |
| 226 | return _PyOS_WindowsConsoleReadline(hStdIn); |
| 227 | } |
| 228 | } |
| 229 | #endif |
| 230 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 231 | n = 100; |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 232 | p = (char *)PyMem_RawMalloc(n); |
| 233 | if (p == NULL) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 234 | return NULL; |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 235 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 236 | fflush(sys_stdout); |
| 237 | if (prompt) |
| 238 | fprintf(stderr, "%s", prompt); |
| 239 | fflush(stderr); |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 240 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 241 | switch (my_fgets(p, (int)n, sys_stdin)) { |
| 242 | case 0: /* Normal case */ |
| 243 | break; |
| 244 | case 1: /* Interrupt */ |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 245 | PyMem_RawFree(p); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 246 | return NULL; |
| 247 | case -1: /* EOF */ |
| 248 | case -2: /* Error */ |
| 249 | default: /* Shouldn't happen */ |
| 250 | *p = '\0'; |
| 251 | break; |
| 252 | } |
| 253 | n = strlen(p); |
| 254 | while (n > 0 && p[n-1] != '\n') { |
| 255 | size_t incr = n+2; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 256 | if (incr > INT_MAX) { |
Victor Stinner | c548660 | 2013-10-19 02:40:16 +0200 | [diff] [blame] | 257 | PyMem_RawFree(p); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 258 | PyErr_SetString(PyExc_OverflowError, "input line too long"); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 259 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 260 | } |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 261 | pr = (char *)PyMem_RawRealloc(p, n + incr); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 262 | if (pr == NULL) { |
Victor Stinner | c548660 | 2013-10-19 02:40:16 +0200 | [diff] [blame] | 263 | PyMem_RawFree(p); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 264 | PyErr_NoMemory(); |
| 265 | return NULL; |
| 266 | } |
| 267 | p = pr; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 268 | if (my_fgets(p+n, (int)incr, sys_stdin) != 0) |
| 269 | break; |
| 270 | n += strlen(p+n); |
| 271 | } |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 272 | pr = (char *)PyMem_RawRealloc(p, n+1); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 273 | if (pr == NULL) { |
Victor Stinner | c548660 | 2013-10-19 02:40:16 +0200 | [diff] [blame] | 274 | PyMem_RawFree(p); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 275 | PyErr_NoMemory(); |
| 276 | return NULL; |
| 277 | } |
| 278 | return pr; |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | |
| 282 | /* By initializing this function pointer, systems embedding Python can |
Guido van Rossum | b18618d | 2000-05-03 23:44:39 +0000 | [diff] [blame] | 283 | override the readline function. |
| 284 | |
| 285 | Note: Python expects in return a buffer allocated with PyMem_Malloc. */ |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 286 | |
Serhiy Storchaka | c679227 | 2013-10-19 21:03:34 +0300 | [diff] [blame] | 287 | char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *); |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 288 | |
| 289 | |
| 290 | /* Interface used by tokenizer.c and bltinmodule.c */ |
| 291 | |
| 292 | char * |
Serhiy Storchaka | c679227 | 2013-10-19 21:03:34 +0300 | [diff] [blame] | 293 | PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 294 | { |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 295 | char *rv, *res; |
| 296 | size_t len; |
Martin v. Löwis | 566f6af | 2002-10-26 14:39:10 +0000 | [diff] [blame] | 297 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 298 | if (_PyOS_ReadlineTState == PyThreadState_GET()) { |
| 299 | PyErr_SetString(PyExc_RuntimeError, |
| 300 | "can't re-enter readline"); |
| 301 | return NULL; |
| 302 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 303 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 304 | |
| 305 | if (PyOS_ReadlineFunctionPointer == NULL) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 306 | PyOS_ReadlineFunctionPointer = PyOS_StdioReadline; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 307 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 308 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 309 | if (_PyOS_ReadlineLock == NULL) { |
| 310 | _PyOS_ReadlineLock = PyThread_allocate_lock(); |
| 311 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 312 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 313 | _PyOS_ReadlineTState = PyThreadState_GET(); |
| 314 | Py_BEGIN_ALLOW_THREADS |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 315 | PyThread_acquire_lock(_PyOS_ReadlineLock, 1); |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 316 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 317 | /* This is needed to handle the unlikely case that the |
| 318 | * interpreter is in interactive mode *and* stdin/out are not |
| 319 | * a tty. This can happen, for example if python is run like |
| 320 | * this: python -i < test1.py |
| 321 | */ |
| 322 | if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout))) |
| 323 | rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt); |
| 324 | else |
| 325 | rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout, |
| 326 | prompt); |
| 327 | Py_END_ALLOW_THREADS |
| 328 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 329 | PyThread_release_lock(_PyOS_ReadlineLock); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 330 | |
| 331 | _PyOS_ReadlineTState = NULL; |
| 332 | |
Victor Stinner | 2fe9bac | 2013-10-10 16:18:20 +0200 | [diff] [blame] | 333 | if (rv == NULL) |
| 334 | return NULL; |
| 335 | |
| 336 | len = strlen(rv) + 1; |
| 337 | res = PyMem_Malloc(len); |
| 338 | if (res != NULL) |
| 339 | memcpy(res, rv, len); |
| 340 | PyMem_RawFree(rv); |
| 341 | |
| 342 | return res; |
Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 343 | } |