Changeset 388 for python/vendor/current/Parser/myreadline.c

Timestamp:

Mar 19, 2014, 11:11:30 AM (11 years ago)

Author:

dmik

Message:

python: Update vendor to 2.7.6.

File:

• python/vendor/current/Parser/myreadline.c (modified) (3 diffs)

python/vendor/current/Parser/myreadline.c

@@ -40 +40 @@
 my_fgets(char *buf, int len, FILE *fp)
 {
-        char *p;
-        for (;;) {
-                if (PyOS_InputHook != NULL)
-                        (void)(PyOS_InputHook)();
-                errno = 0;
-                p = fgets(buf, len, fp);
-                if (p != NULL)
-                        return 0; /* No error */
+    char *p;
 #ifdef MS_WINDOWS
-                /* In the case of a Ctrl+C or some other external event 
-                   interrupting the operation:
-                   Win2k/NT: ERROR_OPERATION_ABORTED is the most recent Win32 
-                   error code (and feof() returns TRUE).
-                   Win9x: Ctrl+C seems to have no effect on fgets() returning
-                   early - the signal handler is called, but the fgets()
-                   only returns "normally" (ie, when Enter hit or feof())
-                */
-                if (GetLastError()==ERROR_OPERATION_ABORTED) {
-                        /* Signals come asynchronously, so we sleep a brief 
-                           moment before checking if the handler has been 
-                           triggered (we cant just return 1 before the 
-                           signal handler has been called, as the later 
-                           signal may be treated as a separate interrupt).
-                        */
-                        Sleep(1);
-                        if (PyOS_InterruptOccurred()) {
-                                return 1; /* Interrupt */
-                        }
-                        /* Either the sleep wasn't long enough (need a
-                           short loop retrying?) or not interrupted at all
-                           (in which case we should revisit the whole thing!)
-                           Logging some warning would be nice.  assert is not
-                           viable as under the debugger, the various dialogs
-                           mean the condition is not true.
-                        */
-                }
+    int i;
+#endif
+
+    while (1) {
+        if (PyOS_InputHook != NULL)
+            (void)(PyOS_InputHook)();
+        errno = 0;
+        clearerr(fp);
+        p = fgets(buf, len, fp);
+        if (p != NULL)
+            return 0; /* No error */
+#ifdef MS_WINDOWS
+        /* Ctrl-C anywhere on the line or Ctrl-Z if the only character
+           on a line will set ERROR_OPERATION_ABORTED. Under normal
+           circumstances Ctrl-C will also have caused the SIGINT handler
+           to fire. This signal fires in another thread and is not
+           guaranteed to have occurred before this point in the code.
+
+           Therefore: check in a small loop to see if the trigger has
+           fired, in which case assume this is a Ctrl-C event. If it
+           hasn't fired within 10ms assume that this is a Ctrl-Z on its
+           own or that the signal isn't going to fire for some other
+           reason and drop through to check for EOF.
+        */
+        if (GetLastError()==ERROR_OPERATION_ABORTED) {
+            for (i = 0; i < 10; i++) {
+                if (PyOS_InterruptOccurred())
+                    return 1;
+                Sleep(1);
+            }
+        }
 #endif /* MS_WINDOWS */
-                if (feof(fp)) {
-                        return -1; /* EOF */
-                }
+        if (feof(fp)) {
+            clearerr(fp);
+            return -1; /* EOF */
+        }
 #ifdef EINTR
-                if (errno == EINTR) {
-                        int s;
-#ifdef WITH_THREAD
-                        PyEval_RestoreThread(_PyOS_ReadlineTState);
-#endif
-                        s = PyErr_CheckSignals();
-#ifdef WITH_THREAD
-                        PyEval_SaveThread();
-#endif
-                        if (s < 0) {
-                                return 1;
-                        }
-                }
-#endif
-                if (PyOS_InterruptOccurred()) {
-                        return 1; /* Interrupt */
-                }
-                return -2; /* Error */
-        }
-        /* NOTREACHED */
+        if (errno == EINTR) {
+            int s;
+#ifdef WITH_THREAD
+            PyEval_RestoreThread(_PyOS_ReadlineTState);
+#endif
+            s = PyErr_CheckSignals();
+#ifdef WITH_THREAD
+            PyEval_SaveThread();
+#endif
+            if (s < 0)
+                    return 1;
+            /* try again */
+            continue;
+        }
+#endif
+        if (PyOS_InterruptOccurred()) {
+            return 1; /* Interrupt */
+        }
+        return -2; /* Error */
+    }
+    /* NOTREACHED */
 }
 
@@ -109 +108 @@
 PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 {
-        size_t n;
-        char *p;
-        n = 100;
-        if ((p = (char *)PyMem_MALLOC(n)) == NULL)
-                return NULL;
-        fflush(sys_stdout);
+    size_t n;
+    char *p;
+    n = 100;
+    if ((p = (char *)PyMem_MALLOC(n)) == NULL)
+        return NULL;
+    fflush(sys_stdout);
 #ifndef RISCOS
-        if (prompt)
-                fprintf(stderr, "%s", prompt);
+    if (prompt)
+        fprintf(stderr, "%s", prompt);
 #else
-        if (prompt) {
-                if(Py_RISCOSWimpFlag)
-                        fprintf(stderr, "\x0cr%s\x0c", prompt);
-                else
-                        fprintf(stderr, "%s", prompt);
-        }
-#endif
-        fflush(stderr);
-        switch (my_fgets(p, (int)n, sys_stdin)) {
-        case 0: /* Normal case */
-                break;
-        case 1: /* Interrupt */
-                PyMem_FREE(p);
-                return NULL;
-        case -1: /* EOF */
-        case -2: /* Error */
-        default: /* Shouldn't happen */
-                *p = '\0';
-                break;
-        }
-        n = strlen(p);
-        while (n > 0 && p[n-1] != '\n') {
-                size_t incr = n+2;
-                p = (char *)PyMem_REALLOC(p, n + incr);
-                if (p == NULL)
-                        return NULL;
-                if (incr > INT_MAX) {
-                        PyErr_SetString(PyExc_OverflowError, "input line too long");
-                }
-                if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
-                        break;
-                n += strlen(p+n);
-        }
-        return (char *)PyMem_REALLOC(p, n+1);
+    if (prompt) {
+        if(Py_RISCOSWimpFlag)
+            fprintf(stderr, "\x0cr%s\x0c", prompt);
+        else
+            fprintf(stderr, "%s", prompt);
+    }
+#endif
+    fflush(stderr);
+    switch (my_fgets(p, (int)n, sys_stdin)) {
+    case 0: /* Normal case */
+        break;
+    case 1: /* Interrupt */
+        PyMem_FREE(p);
+        return NULL;
+    case -1: /* EOF */
+    case -2: /* Error */
+    default: /* Shouldn't happen */
+        *p = '\0';
+        break;
+    }
+    n = strlen(p);
+    while (n > 0 && p[n-1] != '\n') {
+        size_t incr = n+2;
+        p = (char *)PyMem_REALLOC(p, n + incr);
+        if (p == NULL)
+            return NULL;
+        if (incr > INT_MAX) {
+            PyErr_SetString(PyExc_OverflowError, "input line too long");
+        }
+        if (my_fgets(p+n, (int)incr, sys_stdin) != 0)
+            break;
+        n += strlen(p+n);
+    }
+    return (char *)PyMem_REALLOC(p, n+1);
 }
 
@@ -169 +168 @@
 PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 {
-        char *rv;
-
-        if (_PyOS_ReadlineTState == PyThreadState_GET()) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "can't re-enter readline");
-                return NULL;
-        }
-        
-
-        if (PyOS_ReadlineFunctionPointer == NULL) {
+    char *rv;
+
+    if (_PyOS_ReadlineTState == PyThreadState_GET()) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "can't re-enter readline");
+        return NULL;
+    }
+
+
+    if (PyOS_ReadlineFunctionPointer == NULL) {
 #ifdef __VMS
-                PyOS_ReadlineFunctionPointer = vms__StdioReadline;
+        PyOS_ReadlineFunctionPointer = vms__StdioReadline;
 #else
-                PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
-#endif
-        }
-        
-#ifdef WITH_THREAD
-        if (_PyOS_ReadlineLock == NULL) {
-                _PyOS_ReadlineLock = PyThread_allocate_lock();          
-        }
-#endif
-
-        _PyOS_ReadlineTState = PyThreadState_GET();
-        Py_BEGIN_ALLOW_THREADS
-#ifdef WITH_THREAD
-        PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
-#endif
-
-        /* This is needed to handle the unlikely case that the
-         * interpreter is in interactive mode *and* stdin/out are not
-         * a tty.  This can happen, for example if python is run like
-         * this: python -i < test1.py
-         */
-        if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
-                rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
-        else
-                rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
-                                                     prompt);
-        Py_END_ALLOW_THREADS
-
-#ifdef WITH_THREAD
-        PyThread_release_lock(_PyOS_ReadlineLock);
-#endif
-
-        _PyOS_ReadlineTState = NULL;
-
-        return rv;
+        PyOS_ReadlineFunctionPointer = PyOS_StdioReadline;
+#endif
+    }
+
+#ifdef WITH_THREAD
+    if (_PyOS_ReadlineLock == NULL) {
+        _PyOS_ReadlineLock = PyThread_allocate_lock();
+    }
+#endif
+
+    _PyOS_ReadlineTState = PyThreadState_GET();
+    Py_BEGIN_ALLOW_THREADS
+#ifdef WITH_THREAD
+    PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
+#endif
+
+    /* This is needed to handle the unlikely case that the
+     * interpreter is in interactive mode *and* stdin/out are not
+     * a tty.  This can happen, for example if python is run like
+     * this: python -i < test1.py
+     */
+    if (!isatty (fileno (sys_stdin)) || !isatty (fileno (sys_stdout)))
+        rv = PyOS_StdioReadline (sys_stdin, sys_stdout, prompt);
+    else
+        rv = (*PyOS_ReadlineFunctionPointer)(sys_stdin, sys_stdout,
+                                             prompt);
+    Py_END_ALLOW_THREADS
+
+#ifdef WITH_THREAD
+    PyThread_release_lock(_PyOS_ReadlineLock);
+#endif
+
+    _PyOS_ReadlineTState = NULL;
+
+    return rv;
 }