Home | History | Annotate | Download | only in Parser 
      1 
      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.
      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 
     12 #include "Python.h"
     13 #ifdef MS_WINDOWS
     14 #define WIN32_LEAN_AND_MEAN
     15 #include "windows.h"
     16 #endif /* MS_WINDOWS */
     17 
     18 #ifdef __VMS
     19 extern char* vms__StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt);
     20 #endif
     21 
     22 
     23 PyThreadState* _PyOS_ReadlineTState;
     24 
     25 #ifdef WITH_THREAD
     26 #include "pythread.h"
     27 static PyThread_type_lock _PyOS_ReadlineLock = NULL;
     28 #endif
     29 
     30 int (*PyOS_InputHook)(void) = NULL;
     31 
     32 #ifdef RISCOS
     33 int Py_RISCOSWimpFlag;
     34 #endif
     35 
     36 /* This function restarts a fgets() after an EINTR error occurred
     37    except if PyOS_InterruptOccurred() returns true. */
     38 
     39 static int
     40 my_fgets(char *buf, int len, FILE *fp)
     41 {
     42     char *p;
     43 #ifdef MS_WINDOWS
     44     int i;
     45 #endif
     46 
     47     while (1) {
     48         if (PyOS_InputHook != NULL)
     49             (void)(PyOS_InputHook)();
     50         errno = 0;
     51         clearerr(fp);
     52         p = fgets(buf, len, fp);
     53         if (p != NULL)
     54             return 0; /* No error */
     55 #ifdef MS_WINDOWS
     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. This signal fires in another thread and is not
     60            guaranteed to have occurred before this point in the code.
     61 
     62            Therefore: check in a small loop to see if the trigger has
     63            fired, in which case assume this is a Ctrl-C event. If it
     64            hasn't fired within 10ms assume that this is a Ctrl-Z on its
     65            own or that the signal isn't going to fire for some other
     66            reason and drop through to check for EOF.
     67         */
     68         if (GetLastError()==ERROR_OPERATION_ABORTED) {
     69             for (i = 0; i < 10; i++) {
     70                 if (PyOS_InterruptOccurred())
     71                     return 1;
     72                 Sleep(1);
     73             }
     74         }
     75 #endif /* MS_WINDOWS */
     76         if (feof(fp)) {
     77             clearerr(fp);
     78             return -1; /* EOF */
     79         }
     80 #ifdef EINTR
     81         if (errno == EINTR) {
     82             int s;
     83 #ifdef WITH_THREAD
     84             PyEval_RestoreThread(_PyOS_ReadlineTState);
     85 #endif
     86             s = PyErr_CheckSignals();
     87 #ifdef WITH_THREAD
     88             PyEval_SaveThread();
     89 #endif
     90             if (s < 0)
     91                     return 1;
     92 	    /* try again */
     93             continue;
     94         }
     95 #endif
     96         if (PyOS_InterruptOccurred()) {
     97             return 1; /* Interrupt */
     98         }
     99         return -2; /* Error */
    100     }
    101     /* NOTREACHED */
    102 }
    103 
    104 
    105 /* Readline implementation using fgets() */
    106 
    107 char *
    108 PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
    109 {
    110     size_t n;
    111     char *p;
    112     n = 100;
    113     if ((p = (char *)PyMem_MALLOC(n)) == NULL)
    114         return NULL;
    115     fflush(sys_stdout);
    116 #ifndef RISCOS
    117     if (prompt)
    118         fprintf(stderr, "%s", prompt);
    119 #else
    120     if (prompt) {
    121         if(Py_RISCOSWimpFlag)
    122             fprintf(stderr, "\x0cr%s\x0c", prompt);
    123         else
    124             fprintf(stderr, "%s", prompt);
    125     }
    126 #endif
    127     fflush(stderr);
    128     switch (my_fgets(p, (int)n, sys_stdin)) {
    129     case 0: /* Normal case */
    130         break;
    131     case 1: /* Interrupt */
    132         PyMem_FREE(p);
    133         return NULL;
    134     case -1: /* EOF */
    135     case -2: /* Error */
    136     default: /* Shouldn't happen */
    137         *p = '\0';
    138         break;
    139     }
    140     n = strlen(p);
    141     while (n > 0 && p[n-1] != '\n') {
    142         size_t incr = n+2;
    143         p = (char *)PyMem_REALLOC(p, n + incr);
    144         if (p == NULL)
    145             return NULL;
    146         if (incr > INT_MAX) {
    147             PyErr_SetString(PyExc_OverflowError, "input line too long");
    148         }
    149         if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
    150             break;
    151         n += strlen(p+n);
    152     }
    153     return (char *)PyMem_REALLOC(p, n+1);
    154 }
    155 
    156 
    157 /* By initializing this function pointer, systems embedding Python can
    158    override the readline function.
    159 
    160    Note: Python expects in return a buffer allocated with PyMem_Malloc. */
    161 
    162 char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
    163 
    164 
    165 /* Interface used by tokenizer.c and bltinmodule.c */
    166 
    167 char *
    168 PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
    169 {
    170     char *rv;
    171 
    172     if (_PyOS_ReadlineTState == PyThreadState_GET()) {
    173         PyErr_SetString(PyExc_RuntimeError,
    174                         "can't re-enter readline");
    175         return NULL;
    176     }
    177 
    178 
    179     if (PyOS_ReadlineFunctionPointer == NULL) {
    180 #ifdef __VMS
    181         PyOS_ReadlineFunctionPointer = vms__StdioReadline;
    182 #else
    183         PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
    184 #endif
    185     }
    186 
    187 #ifdef WITH_THREAD
    188     if (_PyOS_ReadlineLock == NULL) {
    189         _PyOS_ReadlineLock = PyThread_allocate_lock();
    190     }
    191 #endif
    192 
    193     _PyOS_ReadlineTState = PyThreadState_GET();
    194     Py_BEGIN_ALLOW_THREADS
    195 #ifdef WITH_THREAD
    196     PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
    197 #endif
    198 
    199     /* This is needed to handle the unlikely case that the
    200      * interpreter is in interactive mode *and* stdin/out are not
    201      * a tty.  This can happen, for example if python is run like
    202      * this: python -i < test1.py
    203      */
    204     if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
    205         rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
    206     else
    207         rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
    208                                              prompt);
    209     Py_END_ALLOW_THREADS
    210 
    211 #ifdef WITH_THREAD
    212     PyThread_release_lock(_PyOS_ReadlineLock);
    213 #endif
    214 
    215     _PyOS_ReadlineTState = NULL;
    216 
    217     return rv;
    218 }
    219