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" |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 13 | #ifdef MS_WINDOWS |
| 14 | #define WIN32_LEAN_AND_MEAN |
| 15 | #include "windows.h" |
| 16 | #endif /* MS_WINDOWS */ |
Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 17 | |
Martin v. Löwis | c16f3bd | 2003-05-03 09:14:54 +0000 | [diff] [blame] | 18 | #ifdef __VMS |
| 19 | extern char* vms__StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt); |
| 20 | #endif |
| 21 | |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 22 | |
| 23 | PyThreadState* _PyOS_ReadlineTState; |
| 24 | |
Tim Peters | b7e898a | 2004-07-07 20:42:07 +0000 | [diff] [blame] | 25 | #ifdef WITH_THREAD |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 26 | #include "pythread.h" |
| 27 | static PyThread_type_lock _PyOS_ReadlineLock = NULL; |
| 28 | #endif |
| 29 | |
Thomas Wouters | 23c9e00 | 2000-07-22 19:20:54 +0000 | [diff] [blame] | 30 | int (*PyOS_InputHook)(void) = NULL; |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 31 | |
| 32 | /* This function restarts a fgets() after an EINTR error occurred |
| 33 | except if PyOS_InterruptOccurred() returns true. */ |
| 34 | |
| 35 | static int |
Thomas Wouters | 23c9e00 | 2000-07-22 19:20:54 +0000 | [diff] [blame] | 36 | my_fgets(char *buf, int len, FILE *fp) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 37 | { |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 38 | #ifdef MS_WINDOWS |
| 39 | HANDLE hInterruptEvent; |
| 40 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 41 | char *p; |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 42 | int err; |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 43 | while (1) { |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 44 | if (PyOS_InputHook != NULL) |
| 45 | (void)(PyOS_InputHook)(); |
| 46 | errno = 0; |
Victor Stinner | 4f71101 | 2011-05-30 23:46:00 +0200 | [diff] [blame] | 47 | clearerr(fp); |
Martin v. Löwis | e654c11 | 2012-04-30 06:10:41 +0200 | [diff] [blame] | 48 | if (_PyVerify_fd(fileno(fp))) |
| 49 | p = fgets(buf, len, fp); |
| 50 | else |
| 51 | p = NULL; |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 52 | if (p != NULL) |
| 53 | return 0; /* No error */ |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 54 | err = errno; |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 55 | #ifdef MS_WINDOWS |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 56 | /* Ctrl-C anywhere on the line or Ctrl-Z if the only character |
| 57 | on a line will set ERROR_OPERATION_ABORTED. Under normal |
| 58 | circumstances Ctrl-C will also have caused the SIGINT handler |
| 59 | to fire which will have set the event object returned by |
| 60 | _PyOS_SigintEvent. This signal fires in another thread and |
| 61 | is not guaranteed to have occurred before this point in the |
| 62 | code. |
| 63 | |
| 64 | Therefore: check whether the event is set with a small timeout. |
| 65 | If it is, assume this is a Ctrl-C and reset the event. If it |
| 66 | isn't set assume that this is a Ctrl-Z on its own and drop |
| 67 | through to check for EOF. |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 68 | */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 69 | if (GetLastError()==ERROR_OPERATION_ABORTED) { |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 70 | hInterruptEvent = _PyOS_SigintEvent(); |
| 71 | switch (WaitForSingleObject(hInterruptEvent, 10)) { |
| 72 | case WAIT_OBJECT_0: |
| 73 | ResetEvent(hInterruptEvent); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 74 | return 1; /* Interrupt */ |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 75 | case WAIT_FAILED: |
| 76 | return -2; /* Error */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 77 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 78 | } |
Mark Hammond | 2f10cb8 | 2002-07-14 23:12:29 +0000 | [diff] [blame] | 79 | #endif /* MS_WINDOWS */ |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 80 | if (feof(fp)) { |
Victor Stinner | 4755ab0 | 2011-05-10 00:19:53 +0200 | [diff] [blame] | 81 | clearerr(fp); |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 82 | return -1; /* EOF */ |
| 83 | } |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 84 | #ifdef EINTR |
Antoine Pitrou | c345ce1 | 2011-12-16 12:28:32 +0100 | [diff] [blame] | 85 | if (err == EINTR) { |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 86 | int s; |
Michael W. Hudson | e3afc59 | 2005-04-07 10:11:19 +0000 | [diff] [blame] | 87 | #ifdef WITH_THREAD |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 88 | PyEval_RestoreThread(_PyOS_ReadlineTState); |
Michael W. Hudson | e3afc59 | 2005-04-07 10:11:19 +0000 | [diff] [blame] | 89 | #endif |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 90 | s = PyErr_CheckSignals(); |
Michael W. Hudson | e3afc59 | 2005-04-07 10:11:19 +0000 | [diff] [blame] | 91 | #ifdef WITH_THREAD |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 92 | PyEval_SaveThread(); |
Michael W. Hudson | e3afc59 | 2005-04-07 10:11:19 +0000 | [diff] [blame] | 93 | #endif |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 94 | if (s < 0) |
| 95 | return 1; |
Tim Golden | 9175c3d | 2012-06-29 18:39:26 +0100 | [diff] [blame] | 96 | /* try again */ |
Victor Stinner | 52c950f | 2011-04-09 15:55:44 +0200 | [diff] [blame] | 97 | continue; |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 98 | } |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 99 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 100 | if (PyOS_InterruptOccurred()) { |
| 101 | return 1; /* Interrupt */ |
| 102 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 103 | return -2; /* Error */ |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 104 | } |
Antoine Pitrou | 7f14f0d | 2010-05-09 16:14:21 +0000 | [diff] [blame] | 105 | /* NOTREACHED */ |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | |
| 109 | /* Readline implementation using fgets() */ |
| 110 | |
| 111 | char * |
Martin v. Löwis | 566f6af | 2002-10-26 14:39:10 +0000 | [diff] [blame] | 112 | PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 113 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 114 | size_t n; |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 115 | char *p, *pr; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 116 | n = 100; |
| 117 | if ((p = (char *)PyMem_MALLOC(n)) == NULL) |
| 118 | return NULL; |
| 119 | fflush(sys_stdout); |
| 120 | if (prompt) |
| 121 | fprintf(stderr, "%s", prompt); |
| 122 | fflush(stderr); |
| 123 | switch (my_fgets(p, (int)n, sys_stdin)) { |
| 124 | case 0: /* Normal case */ |
| 125 | break; |
| 126 | case 1: /* Interrupt */ |
| 127 | PyMem_FREE(p); |
| 128 | return NULL; |
| 129 | case -1: /* EOF */ |
| 130 | case -2: /* Error */ |
| 131 | default: /* Shouldn't happen */ |
| 132 | *p = '\0'; |
| 133 | break; |
| 134 | } |
| 135 | n = strlen(p); |
| 136 | while (n > 0 && p[n-1] != '\n') { |
| 137 | size_t incr = n+2; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 138 | if (incr > INT_MAX) { |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 139 | PyMem_FREE(p); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 140 | PyErr_SetString(PyExc_OverflowError, "input line too long"); |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 141 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 142 | } |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 143 | pr = (char *)PyMem_REALLOC(p, n + incr); |
| 144 | if (pr == NULL) { |
| 145 | PyMem_FREE(p); |
| 146 | PyErr_NoMemory(); |
| 147 | return NULL; |
| 148 | } |
| 149 | p = pr; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 150 | if (my_fgets(p+n, (int)incr, sys_stdin) != 0) |
| 151 | break; |
| 152 | n += strlen(p+n); |
| 153 | } |
Christian Heimes | 9ae513c | 2013-08-06 15:59:16 +0200 | [diff] [blame] | 154 | pr = (char *)PyMem_REALLOC(p, n+1); |
| 155 | if (pr == NULL) { |
| 156 | PyMem_FREE(p); |
| 157 | PyErr_NoMemory(); |
| 158 | return NULL; |
| 159 | } |
| 160 | return pr; |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | |
| 164 | /* By initializing this function pointer, systems embedding Python can |
Guido van Rossum | b18618d | 2000-05-03 23:44:39 +0000 | [diff] [blame] | 165 | override the readline function. |
| 166 | |
| 167 | Note: Python expects in return a buffer allocated with PyMem_Malloc. */ |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 168 | |
Martin v. Löwis | 566f6af | 2002-10-26 14:39:10 +0000 | [diff] [blame] | 169 | char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *); |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 170 | |
| 171 | |
| 172 | /* Interface used by tokenizer.c and bltinmodule.c */ |
| 173 | |
| 174 | char * |
Martin v. Löwis | 566f6af | 2002-10-26 14:39:10 +0000 | [diff] [blame] | 175 | PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt) |
Guido van Rossum | fbd64c8 | 1997-02-18 21:53:32 +0000 | [diff] [blame] | 176 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 177 | char *rv; |
Martin v. Löwis | 566f6af | 2002-10-26 14:39:10 +0000 | [diff] [blame] | 178 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 179 | if (_PyOS_ReadlineTState == PyThreadState_GET()) { |
| 180 | PyErr_SetString(PyExc_RuntimeError, |
| 181 | "can't re-enter readline"); |
| 182 | return NULL; |
| 183 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 184 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 185 | |
| 186 | if (PyOS_ReadlineFunctionPointer == NULL) { |
Martin v. Löwis | c16f3bd | 2003-05-03 09:14:54 +0000 | [diff] [blame] | 187 | #ifdef __VMS |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 188 | PyOS_ReadlineFunctionPointer = vms__StdioReadline; |
Martin v. Löwis | c16f3bd | 2003-05-03 09:14:54 +0000 | [diff] [blame] | 189 | #else |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 190 | PyOS_ReadlineFunctionPointer = PyOS_StdioReadline; |
Martin v. Löwis | c16f3bd | 2003-05-03 09:14:54 +0000 | [diff] [blame] | 191 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 192 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 193 | |
Tim Peters | b7e898a | 2004-07-07 20:42:07 +0000 | [diff] [blame] | 194 | #ifdef WITH_THREAD |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 195 | if (_PyOS_ReadlineLock == NULL) { |
| 196 | _PyOS_ReadlineLock = PyThread_allocate_lock(); |
| 197 | } |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 198 | #endif |
| 199 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 200 | _PyOS_ReadlineTState = PyThreadState_GET(); |
| 201 | Py_BEGIN_ALLOW_THREADS |
| 202 | #ifdef WITH_THREAD |
| 203 | PyThread_acquire_lock(_PyOS_ReadlineLock, 1); |
| 204 | #endif |
Michael W. Hudson | 30ea2f2 | 2004-07-07 17:44:12 +0000 | [diff] [blame] | 205 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 206 | /* This is needed to handle the unlikely case that the |
| 207 | * interpreter is in interactive mode *and* stdin/out are not |
| 208 | * a tty. This can happen, for example if python is run like |
| 209 | * this: python -i < test1.py |
| 210 | */ |
| 211 | if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout))) |
| 212 | rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt); |
| 213 | else |
| 214 | rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout, |
| 215 | prompt); |
| 216 | Py_END_ALLOW_THREADS |
| 217 | |
| 218 | #ifdef WITH_THREAD |
| 219 | PyThread_release_lock(_PyOS_ReadlineLock); |
| 220 | #endif |
| 221 | |
| 222 | _PyOS_ReadlineTState = NULL; |
| 223 | |
| 224 | return rv; |
Guido van Rossum | 6fa6343 | 1993-12-24 10:36:57 +0000 | [diff] [blame] | 225 | } |