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