blob: 32a1088ad09b95fd697830b8bf073af2bb097170 [file] [log] [blame]
Guido van Rossum6fa63431993-12-24 10:36:57 +00001
Guido van Rossumfbd64c81997-02-18 21:53:32 +00002/* 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 Rossum6fa63431993-12-24 10:36:57 +00006 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 Rossum8efa47b1998-08-27 19:43:43 +000012#include "Python.h"
Mark Hammond2f10cb82002-07-14 23:12:29 +000013#ifdef MS_WINDOWS
14#define WIN32_LEAN_AND_MEAN
15#include "windows.h"
16#endif /* MS_WINDOWS */
Guido van Rossum6fa63431993-12-24 10:36:57 +000017
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +000018#ifdef __VMS
19extern char* vms__StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt);
20#endif
21
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000022
23PyThreadState* _PyOS_ReadlineTState;
24
Tim Petersb7e898a2004-07-07 20:42:07 +000025#ifdef WITH_THREAD
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000026#include "pythread.h"
27static PyThread_type_lock _PyOS_ReadlineLock = NULL;
28#endif
29
Thomas Wouters23c9e002000-07-22 19:20:54 +000030int (*PyOS_InputHook)(void) = NULL;
Guido van Rossumfbd64c81997-02-18 21:53:32 +000031
Guido van Rossum48a680c2001-03-02 06:34:14 +000032#ifdef RISCOS
33int Py_RISCOSWimpFlag;
34#endif
35
Guido van Rossumfbd64c81997-02-18 21:53:32 +000036/* This function restarts a fgets() after an EINTR error occurred
37 except if PyOS_InterruptOccurred() returns true. */
38
39static int
Thomas Wouters23c9e002000-07-22 19:20:54 +000040my_fgets(char *buf, int len, FILE *fp)
Guido van Rossumfbd64c81997-02-18 21:53:32 +000041{
42 char *p;
43 for (;;) {
Guido van Rossum44620641997-08-11 18:57:29 +000044 if (PyOS_InputHook != NULL)
45 (void)(PyOS_InputHook)();
Guido van Rossumfbd64c81997-02-18 21:53:32 +000046 errno = 0;
47 p = fgets(buf, len, fp);
48 if (p != NULL)
49 return 0; /* No error */
Mark Hammond2f10cb82002-07-14 23:12:29 +000050#ifdef MS_WINDOWS
51 /* In the case of a Ctrl+C or some other external event
52 interrupting the operation:
53 Win2k/NT: ERROR_OPERATION_ABORTED is the most recent Win32
54 error code (and feof() returns TRUE).
55 Win9x: Ctrl+C seems to have no effect on fgets() returning
56 early - the signal handler is called, but the fgets()
57 only returns "normally" (ie, when Enter hit or feof())
58 */
59 if (GetLastError()==ERROR_OPERATION_ABORTED) {
60 /* Signals come asynchronously, so we sleep a brief
61 moment before checking if the handler has been
62 triggered (we cant just return 1 before the
63 signal handler has been called, as the later
64 signal may be treated as a separate interrupt).
65 */
66 Sleep(1);
67 if (PyOS_InterruptOccurred()) {
68 return 1; /* Interrupt */
69 }
70 /* Either the sleep wasn't long enough (need a
71 short loop retrying?) or not interrupted at all
72 (in which case we should revisit the whole thing!)
73 Logging some warning would be nice. assert is not
74 viable as under the debugger, the various dialogs
75 mean the condition is not true.
76 */
77 }
78#endif /* MS_WINDOWS */
Guido van Rossumfbd64c81997-02-18 21:53:32 +000079 if (feof(fp)) {
80 return -1; /* EOF */
81 }
82#ifdef EINTR
83 if (errno == EINTR) {
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000084 int s;
Michael W. Hudsone3afc592005-04-07 10:11:19 +000085#ifdef WITH_THREAD
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000086 PyEval_RestoreThread(_PyOS_ReadlineTState);
Michael W. Hudsone3afc592005-04-07 10:11:19 +000087#endif
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000088 s = PyErr_CheckSignals();
Michael W. Hudsone3afc592005-04-07 10:11:19 +000089#ifdef WITH_THREAD
Michael W. Hudson23849902004-07-08 15:28:26 +000090 PyEval_SaveThread();
Michael W. Hudsone3afc592005-04-07 10:11:19 +000091#endif
Michael W. Hudson30ea2f22004-07-07 17:44:12 +000092 if (s < 0) {
93 return 1;
Guido van Rossumfbd64c81997-02-18 21:53:32 +000094 }
Guido van Rossumfbd64c81997-02-18 21:53:32 +000095 }
96#endif
97 if (PyOS_InterruptOccurred()) {
98 return 1; /* Interrupt */
99 }
100 return -2; /* Error */
101 }
102 /* NOTREACHED */
103}
104
105
106/* Readline implementation using fgets() */
107
108char *
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000109PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000110{
Guido van Rossum6da34342000-06-28 22:00:02 +0000111 size_t n;
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000112 char *p;
Guido van Rossum6fa63431993-12-24 10:36:57 +0000113 n = 100;
Neal Norwitz08062d62006-04-11 08:19:15 +0000114 if ((p = (char *)PyMem_MALLOC(n)) == NULL)
Guido van Rossum6fa63431993-12-24 10:36:57 +0000115 return NULL;
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000116 fflush(sys_stdout);
Guido van Rossum48a680c2001-03-02 06:34:14 +0000117#ifndef RISCOS
Guido van Rossum6fa63431993-12-24 10:36:57 +0000118 if (prompt)
119 fprintf(stderr, "%s", prompt);
Guido van Rossum48a680c2001-03-02 06:34:14 +0000120#else
121 if (prompt) {
122 if(Py_RISCOSWimpFlag)
123 fprintf(stderr, "\x0cr%s\x0c", prompt);
124 else
125 fprintf(stderr, "%s", prompt);
126 }
127#endif
Guido van Rossumc7fea2f1996-01-12 01:30:55 +0000128 fflush(stderr);
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000129 switch (my_fgets(p, (int)n, sys_stdin)) {
Guido van Rossumb6775db1994-08-01 11:34:53 +0000130 case 0: /* Normal case */
131 break;
132 case 1: /* Interrupt */
Neal Norwitz08062d62006-04-11 08:19:15 +0000133 PyMem_FREE(p);
Guido van Rossum6fa63431993-12-24 10:36:57 +0000134 return NULL;
Guido van Rossumb6775db1994-08-01 11:34:53 +0000135 case -1: /* EOF */
136 case -2: /* Error */
137 default: /* Shouldn't happen */
138 *p = '\0';
139 break;
Guido van Rossum6fa63431993-12-24 10:36:57 +0000140 }
141 n = strlen(p);
142 while (n > 0 && p[n-1] != '\n') {
Guido van Rossum6da34342000-06-28 22:00:02 +0000143 size_t incr = n+2;
Neal Norwitz08062d62006-04-11 08:19:15 +0000144 p = (char *)PyMem_REALLOC(p, n + incr);
Guido van Rossum6fa63431993-12-24 10:36:57 +0000145 if (p == NULL)
146 return NULL;
Guido van Rossum6da34342000-06-28 22:00:02 +0000147 if (incr > INT_MAX) {
148 PyErr_SetString(PyExc_OverflowError, "input line too long");
149 }
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000150 if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
Guido van Rossum6fa63431993-12-24 10:36:57 +0000151 break;
152 n += strlen(p+n);
153 }
Neal Norwitz08062d62006-04-11 08:19:15 +0000154 return (char *)PyMem_REALLOC(p, n+1);
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000155}
156
157
158/* By initializing this function pointer, systems embedding Python can
Guido van Rossumb18618d2000-05-03 23:44:39 +0000159 override the readline function.
160
Neal Norwitz08062d62006-04-11 08:19:15 +0000161 Note: Python expects in return a buffer allocated with PyMem_Malloc. */
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000162
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000163char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000164
165
166/* Interface used by tokenizer.c and bltinmodule.c */
167
168char *
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000169PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000170{
Guido van Rossum80c7bcf1998-08-29 16:03:27 +0000171 char *rv;
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000172
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000173 if (_PyOS_ReadlineTState == PyThreadState_GET()) {
174 PyErr_SetString(PyExc_RuntimeError,
175 "can't re-enter readline");
176 return NULL;
177 }
178
179
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000180 if (PyOS_ReadlineFunctionPointer == NULL) {
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +0000181#ifdef __VMS
182 PyOS_ReadlineFunctionPointer = vms__StdioReadline;
183#else
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000184 PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +0000185#endif
Guido van Rossumfbd64c81997-02-18 21:53:32 +0000186 }
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000187
Tim Petersb7e898a2004-07-07 20:42:07 +0000188#ifdef WITH_THREAD
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000189 if (_PyOS_ReadlineLock == NULL) {
190 _PyOS_ReadlineLock = PyThread_allocate_lock();
191 }
192#endif
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000193
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000194 _PyOS_ReadlineTState = PyThreadState_GET();
Guido van Rossum8efa47b1998-08-27 19:43:43 +0000195 Py_BEGIN_ALLOW_THREADS
Tim Petersb7e898a2004-07-07 20:42:07 +0000196#ifdef WITH_THREAD
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000197 PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
198#endif
Martin v. Löwis566f6af2002-10-26 14:39:10 +0000199
200 /* This is needed to handle the unlikely case that the
201 * interpreter is in interactive mode *and* stdin/out are not
202 * a tty. This can happen, for example if python is run like
203 * this: python -i < test1.py
204 */
205 if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
206 rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
207 else
208 rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
209 prompt);
Guido van Rossum8efa47b1998-08-27 19:43:43 +0000210 Py_END_ALLOW_THREADS
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000211
Tim Petersb7e898a2004-07-07 20:42:07 +0000212#ifdef WITH_THREAD
Michael W. Hudson30ea2f22004-07-07 17:44:12 +0000213 PyThread_release_lock(_PyOS_ReadlineLock);
214#endif
215
216 _PyOS_ReadlineTState = NULL;
217
Guido van Rossum80c7bcf1998-08-29 16:03:27 +0000218 return rv;
Guido van Rossum6fa63431993-12-24 10:36:57 +0000219}